/* ========================================================================
 * Copyright (c) 2005-2024 The OPC Foundation, Inc. All rights reserved.
 *
 * OPC Foundation MIT License 1.00
 *
 * Permission is hereby granted, free of charge, to any person
 * obtaining a copy of this software and associated documentation
 * files (the "Software"), to deal in the Software without
 * restriction, including without limitation the rights to use,
 * copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following
 * conditions:
 *
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 *
 * The complete license agreement can be found here:
 * http://opcfoundation.org/License/MIT/1.00/
 * ======================================================================*/

using System;
using System.Collections.Generic;
using System.Text;
using System.Xml;
using System.Runtime.Serialization;
using Opc.Ua;

namespace Measurements
{
    #region MeasurementContainerState Class
    #if (!OPCUA_EXCLUDE_MeasurementContainerState)
    /// <remarks />
    /// <exclude />
    [System.CodeDom.Compiler.GeneratedCodeAttribute("Opc.Ua.ModelCompiler", "1.0.0.0")]
    public partial class MeasurementContainerState : BaseObjectState
    {
        #region Constructors
        /// <remarks />
        public MeasurementContainerState(NodeState parent) : base(parent)
        {
        }

        /// <remarks />
        protected override NodeId GetDefaultTypeDefinitionId(NamespaceTable namespaceUris)
        {
            return Opc.Ua.NodeId.Create(Measurements.ObjectTypes.MeasurementContainerType, Measurements.Namespaces.Measurements, namespaceUris);
        }

        #if (!OPCUA_EXCLUDE_InitializationStrings)
        /// <remarks />
        protected override void Initialize(ISystemContext context)
        {
            base.Initialize(context);
            Initialize(context, InitializationString);
            InitializeOptionalChildren(context);
        }

        /// <remarks />
        protected override void Initialize(ISystemContext context, NodeState source)
        {
            InitializeOptionalChildren(context);
            base.Initialize(context, source);
        }

        /// <remarks />
        protected override void InitializeOptionalChildren(ISystemContext context)
        {
            base.InitializeOptionalChildren(context);
        }

        #region Initialization String
        private const string InitializationString =
           "AQAAADUAAAB1cm46b3BjZm91bmRhdGlvbi5vcmc6MjAyNC0xMDpzdGFydGVya2l0Om1lYXN1cmVtZW50" +
           "c/////8EYIACAQAAAAEAIAAAAE1lYXN1cmVtZW50Q29udGFpbmVyVHlwZUluc3RhbmNlAQEBAAEBAQAB" +
           "AAAA/////2gAAAAVYIkKAgAAAAEACwAAAFRlbXBlcmF0dXJlAQECAAAvAQBZRAIAAAAAC/////8BAf//" +
           "//8BAAAAFWCpCgIAAAAAABAAAABFbmdpbmVlcmluZ1VuaXRzAQEHAAAuAQBZRAcAAAAWAQB5AwFXAAAA" +
           "LwAAAGh0dHA6Ly93d3cub3BjZm91bmRhdGlvbi5vcmcvVUEvdW5pdHMvdW4vY2VmYWN0TEVDAAMCAAAA" +
           "ZW4DAAAAwrBDAwIAAABlbgcAAABDZWxzaXVzAQB3A/////8BAf////8BAAAAFWCJCgIAAAAAABAAAABF" +
           "bmdpbmVlcmluZ1VuaXRzAQEMAAAuAEQMAAAAAQB3A/////8BAf////8AAAAAFWCJCgIAAAABAAgAAABQ" +
           "cmVzc3VyZQEBDQAALwEAWUQNAAAAAAv/////AQH/////AQAAABVgqQoCAAAAAAAQAAAARW5naW5lZXJp" +
           "bmdVbml0cwEBEgAALgEAWUQSAAAAFgEAeQMBWgAAAC8AAABodHRwOi8vd3d3Lm9wY2ZvdW5kYXRpb24u" +
           "b3JnL1VBL3VuaXRzL3VuL2NlZmFjdEFQSwADAgAAAGVuAwAAAGtQYQMCAAAAZW4KAAAAa2lsb3Bhc2Nh" +
           "bAEAdwP/////AQH/////AQAAABVgiQoCAAAAAAAQAAAARW5naW5lZXJpbmdVbml0cwEBFwAALgBEFwAA" +
           "AAEAdwP/////AQH/////AAAAAARhggoEAAAAAQAFAAAAUmVzZXQBARgAAC8BARgAGAAAAAEB/////wIA" +
           "AAAXYKkKAgAAAAAADgAAAElucHV0QXJndW1lbnRzAQEZAAAuAEQZAAAAlgIAAAABACoBAR0AAAAOAAAA" +
           "TmV3VGVtcGVyYXR1cmUAC/////8AAAAAAAEAKgEBGgAAAAsAAABOZXdQcmVzc3VyZQAL/////wAAAAAA" +
           "AQAoAQEAAAABAAAAAgAAAAEB/////wAAAAAXYKkKAgAAAAAADwAAAE91dHB1dEFyZ3VtZW50cwEBGgAA" +
           "LgBEGgAAAJYCAAAAAQAqAQEdAAAADgAAAE9sZFRlbXBlcmF0dXJlAAv/////AAAAAAABACoBARoAAAAL" +
           "AAAAT2xkUHJlc3N1cmUAC/////8AAAAAAAEAKAEBAAAAAQAAAAIAAAABAf////8AAAAAFWCJCgIAAAAB" +
           "AAsAAABPcmllbnRhdGlvbgEBGwAALwA/GwAAAAEBHwD/////AQH/////AAAAABVgiQoCAAAAAQAFAAAA" +
           "U3BlZWQBAT8AAC8APz8AAAAAC/////8BAf////8AAAAAF2CJCgIAAAABAAkAAABBcnJheVRlc3QBAUAA" +
           "AC8AP0AAAAAABgEAAAABAAAACgAAAAEB/////wAAAAAVYIkKAgAAAAEACwAAAEJvb2xlYW5UZXN0AQFC" +
           "AAAvAD9CAAAAAAH/////AQH/////AAAAABVgiQoCAAAAAQAHAAAAc3dpdGNoMAEBkgAALwA/kgAAAAAG" +
           "/////wEB/////wAAAAAVYIkKAgAAAAEABwAAAHN3aXRjaDEBAUMAAC8AP0MAAAAAAf////8BAf////8A" +
           "AAAAFWCJCgIAAAABAAcAAABzd2l0Y2gyAQFEAAAvAD9EAAAAAAH/////AQH/////AAAAABVgiQoCAAAA" +
           "AQAHAAAAc3dpdGNoMwEBRQAALwA/RQAAAAAB/////wEB/////wAAAAAVYIkKAgAAAAEABwAAAHN3aXRj" +
           "aDQBAUYAAC8AP0YAAAAAAf////8BAf////8AAAAAFWCJCgIAAAABAAoAAABmbG93UmF0ZVJUAQFHAAAv" +
           "AD9HAAAAAAv/////AQH/////AAAAABVgiQoCAAAAAQAGAAAAaGVhdFJUAQFIAAAvAD9IAAAAAAv/////" +
           "AQH/////AAAAABVgiQoCAAAAAQANAAAAdmFsdmVPcGVuUmF0ZQEBSQAALwA/SQAAAAAL/////wEB////" +
           "/wAAAAAVYIkKAgAAAAEAEwAAAHJldHVybldhdGVyUHJlc3N1cmUBAUoAAC8AP0oAAAAAC/////8BAf//" +
           "//8AAAAAFWCJCgIAAAABAA8AAAByZXR1cm5XYXRlclRlbXABAUsAAC8AP0sAAAAAC/////8BAf////8A" +
           "AAAAFWCJCgIAAAABABMAAABzdXBwbHlXYXRlclByZXNzdXJlAQFMAAAvAD9MAAAAAAv/////AQH/////" +
           "AAAAABVgiQoCAAAAAQAPAAAAc3VwcGx5V2F0ZXJUZW1wAQFNAAAvAD9NAAAAAAv/////AQH/////AAAA" +
           "ABVgiQoCAAAAAQAJAAAAcHVtcEZyZXExAQFOAAAvAD9OAAAAAAv/////AQH/////AAAAABVgiQoCAAAA" +
           "AQAUAAAAcmV0dXJuV2F0ZXJQcmVzc3VyZTIBAU8AAC8AP08AAAAAC/////8BAf////8AAAAAFWCJCgIA" +
           "AAABABAAAAByZXR1cm5XYXRlclRlbXAyAQFQAAAvAD9QAAAAAAv/////AQH/////AAAAABVgiQoCAAAA" +
           "AQALAAAAZmxvd1JhdGVSVDIBAVEAAC8AP1EAAAAAC/////8BAf////8AAAAAFWCJCgIAAAABAAcAAABo" +
           "ZWF0UlQyAQFSAAAvAD9SAAAAAAv/////AQH/////AAAAABVgiQoCAAAAAQASAAAAZmlsdGVyUHJlc3N1" +
           "cmVEaWZmAQFTAAAvAD9TAAAAAAv/////AQH/////AAAAABVgiQoCAAAAAQAUAAAAc3VwcGx5V2F0ZXJQ" +
           "cmVzc3VyZTIBAVQAAC8AP1QAAAAAC/////8BAf////8AAAAAFWCJCgIAAAABABAAAABzdXBwbHlXYXRl" +
           "clRlbXAyAQFVAAAvAD9VAAAAAAv/////AQH/////AAAAABVgiQoCAAAAAQAUAAAAc3VwcGx5V2F0ZXJQ" +
           "cmVzc3VyZTMBAVYAAC8AP1YAAAAAC/////8BAf////8AAAAAFWCJCgIAAAABABAAAABzdXBwbHlXYXRl" +
           "clRlbXAzAQFwAAAvAD9wAAAAAAv/////AQH/////AAAAABVgiQoCAAAAAQAJAAAAcHVtcEZyZXEyAQFY" +
           "AAAvAD9YAAAAAAv/////AQH/////AAAAABVgiQoCAAAAAQAJAAAAcHVtcEZyZXEzAQFZAAAvAD9ZAAAA" +
           "AAv/////AQH/////AAAAABVgiQoCAAAAAQAJAAAAcHVtcEZyZXE0AQFaAAAvAD9aAAAAAAv/////AQH/" +
           "////AAAAABVgiQoCAAAAAQAUAAAAcmV0dXJuV2F0ZXJQcmVzc3VyZTMBAVsAAC8AP1sAAAAAC/////8B" +
           "Af////8AAAAAFWCJCgIAAAABABAAAAByZXR1cm5XYXRlclRlbXAzAQFcAAAvAD9cAAAAAAv/////AQH/" +
           "////AAAAABVgiQoCAAAAAQATAAAAZmlsdGVyUHJlc3N1cmVEaWZmMgEBXQAALwA/XQAAAAAL/////wEB" +
           "/////wAAAAAVYIkKAgAAAAEACwAAAGZsb3dSYXRlUlQzAQFeAAAvAD9eAAAAAAv/////AQH/////AAAA" +
           "ABVgiQoCAAAAAQAHAAAAaGVhdFJUMwEBXwAALwA/XwAAAAAL/////wEB/////wAAAAAVYIkKAgAAAAEA" +
           "EwAAAGZpbHRlclByZXNzdXJlRGlmZjMBAWAAAC8AP2AAAAAAC/////8BAf////8AAAAAFWCJCgIAAAAB" +
           "AAsAAABmbG93UmF0ZVJUNAEBYQAALwA/YQAAAAAL/////wEB/////wAAAAAVYIkKAgAAAAEABwAAAGhl" +
           "YXRSVDQBAWIAAC8AP2IAAAAAC/////8BAf////8AAAAAFWCJCgIAAAABAAsAAABmbG93UmF0ZVJUNQEB" +
           "YwAALwA/YwAAAAAL/////wEB/////wAAAAAVYIkKAgAAAAEABwAAAGhlYXRSVDUBAWQAAC8AP2QAAAAA" +
           "C/////8BAf////8AAAAAFWCJCgIAAAABAAsAAABmbG93UmF0ZVJUNgEBZQAALwA/ZQAAAAAL/////wEB" +
           "/////wAAAAAVYIkKAgAAAAEABwAAAGhlYXRSVDYBAWYAAC8AP2YAAAAAC/////8BAf////8AAAAAFWCJ" +
           "CgIAAAABAA4AAAB2YWx2ZU9wZW5SYXRlMgEBZwAALwA/ZwAAAAAL/////wEB/////wAAAAAVYIkKAgAA" +
           "AAEACQAAAHRhbmtMZXZlbAEBaAAALwA/aAAAAAAL/////wEB/////wAAAAAVYIkKAgAAAAEACwAAAGZs" +
           "b3dSYXRlUlQ3AQFpAAAvAD9pAAAAAAv/////AQH/////AAAAABVgiQoCAAAAAQAHAAAAaGVhdFJUNwEB" +
           "agAALwA/agAAAAAL/////wEB/////wAAAAAVYIkKAgAAAAEACgAAAHdhdGVyTGV2ZWwBAWsAAC8AP2sA" +
           "AAAAC/////8BAf////8AAAAAF2CJCgIAAAABAAsAAABoZWF0X2NoYXJ0MQEBbAAALwA/bAAAAAAGAQAA" +
           "AAEAAAAKAAAAAQH/////AAAAABdgiQoCAAAAAQALAAAAaGVhdF9jaGFydDIBAW0AAC8AP20AAAAABgEA" +
           "AAABAAAACgAAAAEB/////wAAAAAXYIkKAgAAAAEADQAAAGhlYXRfY2hhcnQzXzEBAXUAAC8AP3UAAAAA" +
           "BgEAAAABAAAACgAAAAEB/////wAAAAAXYIkKAgAAAAEADQAAAGhlYXRfY2hhcnQzXzIBAXYAAC8AP3YA" +
           "AAAABgEAAAABAAAACgAAAAEB/////wAAAAAXYIkKAgAAAAEADQAAAGhlYXRfY2hhcnQ0XzEBAXEAAC8A" +
           "P3EAAAAABgEAAAABAAAACgAAAAEB/////wAAAAAXYIkKAgAAAAEADQAAAGhlYXRfY2hhcnQ0XzIBAXIA" +
           "AC8AP3IAAAAABgEAAAABAAAACgAAAAEB/////wAAAAAXYIkKAgAAAAEADQAAAGhlYXRfY2hhcnQ0XzMB" +
           "AXMAAC8AP3MAAAAABgEAAAABAAAACgAAAAEB/////wAAAAAXYIkKAgAAAAEADQAAAGhlYXRfY2hhcnQ0" +
           "XzQBAXQAAC8AP3QAAAAABgEAAAABAAAACgAAAAEB/////wAAAAAVYIkKAgAAAAEACQAAAHllYXJQbGFu" +
           "MQEBdwAALwA/dwAAAAAL/////wEB/////wAAAAAVYIkKAgAAAAEACQAAAHllYXJQbGFuMgEBeAAALwA/" +
           "eAAAAAAL/////wEB/////wAAAAAVYIkKAgAAAAEACQAAAHllYXJQbGFuMwEBeQAALwA/eQAAAAAL////" +
           "/wEB/////wAAAAAVYIkKAgAAAAEACgAAAG1vbnRoUGxhbjEBAXoAAC8AP3oAAAAAC/////8BAf////8A" +
           "AAAAFWCJCgIAAAABAAoAAABtb250aFBsYW4yAQF7AAAvAD97AAAAAAv/////AQH/////AAAAABVgiQoC" +
           "AAAAAQAKAAAAbW9udGhQbGFuMwEBfAAALwA/fAAAAAAL/////wEB/////wAAAAAVYIkKAgAAAAEACgAA" +
           "AG1vbnRoUGxhbjQBAX0AAC8AP30AAAAAC/////8BAf////8AAAAAFWCJCgIAAAABAAgAAABkYXlQbGFu" +
           "MQEBfgAALwA/fgAAAAAL/////wEB/////wAAAAAVYIkKAgAAAAEACAAAAGRheVBsYW4yAQF/AAAvAD9/" +
           "AAAAAAv/////AQH/////AAAAABVgiQoCAAAAAQAIAAAAZGF5UGxhbjMBAYAAAC8AP4AAAAAAC/////8B" +
           "Af////8AAAAAFWCJCgIAAAABAAgAAABkYXlQbGFuNAEBgQAALwA/gQAAAAAL/////wEB/////wAAAAAV" +
           "YIkKAgAAAAEACgAAAHN0b3JlRGF0YTEBAYIAAC8AP4IAAAAAC/////8BAf////8AAAAAFWCJCgIAAAAB" +
           "AAoAAABzdG9yZURhdGEyAQGDAAAvAD+DAAAAAAv/////AQH/////AAAAABVgiQoCAAAAAQAKAAAAc3Rv" +
           "cmVEYXRhMwEBhAAALwA/hAAAAAAL/////wEB/////wAAAAAXYIkKAgAAAAEADgAAAG1ldGVyX2NoYXJ0" +
           "MV8xAQGFAAAvAD+FAAAAAAYBAAAAAQAAAAwAAAABAf////8AAAAAF2CJCgIAAAABAA4AAABtZXRlcl9j" +
           "aGFydDFfMgEBhgAALwA/hgAAAAAGAQAAAAEAAAAMAAAAAQH/////AAAAABdgiQoCAAAAAQAOAAAAbWV0" +
           "ZXJfY2hhcnQyXzEBAYcAAC8AP4cAAAAABgEAAAABAAAADAAAAAEB/////wAAAAAXYIkKAgAAAAEADgAA" +
           "AG1ldGVyX2NoYXJ0Ml8yAQGIAAAvAD+IAAAAAAYBAAAAAQAAAAwAAAABAf////8AAAAAF2CJCgIAAAAB" +
           "AA4AAABtZXRlcl9jaGFydDNfMQEBiQAALwA/iQAAAAAGAQAAAAEAAAAMAAAAAQH/////AAAAABdgiQoC" +
           "AAAAAQAOAAAAbWV0ZXJfY2hhcnQzXzIBAYoAAC8AP4oAAAAABgEAAAABAAAADAAAAAEB/////wAAAAAX" +
           "YIkKAgAAAAEACwAAAG1ldGVyX3RhYmxlAQGLAAAvAD+LAAAAAAYBAAAAAQAAAFAAAAABAf////8AAAAA" +
           "F2CJCgIAAAABAAwAAAB0ZW1wZXJhdHVyZXMBAYwAAC8AP4wAAAAABgEAAAABAAAADwAAAAEB/////wAA" +
           "AAAXYIkKAgAAAAEACQAAAHByZXNzdXJlcwEBjQAALwA/jQAAAAAGAQAAAAEAAAAMAAAAAQH/////AAAA" +
           "ABdgiQoCAAAAAQAQAAAAZnVybmFjZV9jaGFydDFfMQEBjgAALwA/jgAAAAAGAQAAAAEAAAAMAAAAAQH/" +
           "////AAAAABdgiQoCAAAAAQAQAAAAZnVybmFjZV9jaGFydDFfMgEBjwAALwA/jwAAAAAGAQAAAAEAAAAM" +
           "AAAAAQH/////AAAAABdgiQoCAAAAAQAQAAAAZnVybmFjZV9jaGFydDJfMQEBkAAALwA/kAAAAAAGAQAA" +
           "AAEAAAAMAAAAAQH/////AAAAABdgiQoCAAAAAQAQAAAAZnVybmFjZV9jaGFydDJfMgEBkQAALwA/kQAA" +
           "AAAGAQAAAAEAAAAMAAAAAQH/////AAAAABdgiQoCAAAAAQATAAAAYmxhc3RmdXJuYWNlX2VuZXJneQEB" +
           "pAAALwA/pAAAAAAGAQAAAAEAAAAJAAAAAQH/////AAAAABdgiQoCAAAAAQASAAAAYmxhc3RmdXJuYWNl" +
           "X3lpZWxkAQGlAAAvAD+lAAAAAAYBAAAAAQAAAAMAAAABAf////8AAAAAF2CJCgIAAAABABYAAABibGFz" +
           "dGZ1cm5hY2VfY29uZGl0aW9uAQGmAAAvAD+mAAAAAAsBAAAAAQAAAAUAAAABAf////8AAAAAF2CJCgIA" +
           "AAABABUAAABibGFzdGZ1cm5hY2VfY2hhcnQxXzEBAZMAAC8AP5MAAAAABgEAAAABAAAACQAAAAEB////" +
           "/wAAAAAXYIkKAgAAAAEAFQAAAGJsYXN0ZnVybmFjZV9jaGFydDFfMgEBlAAALwA/lAAAAAAGAQAAAAEA" +
           "AAAJAAAAAQH/////AAAAABdgiQoCAAAAAQAVAAAAYmxhc3RmdXJuYWNlX2NoYXJ0Ml8xAQGVAAAvAD+V" +
           "AAAAAAYBAAAAAQAAAAkAAAABAf////8AAAAAF2CJCgIAAAABABUAAABibGFzdGZ1cm5hY2VfY2hhcnQy" +
           "XzIBAZYAAC8AP5YAAAAABgEAAAABAAAACQAAAAEB/////wAAAAAXYIkKAgAAAAEAFQAAAGJsYXN0ZnVy" +
           "bmFjZV9jaGFydDJfMwEBlwAALwA/lwAAAAAGAQAAAAEAAAAJAAAAAQH/////AAAAABdgiQoCAAAAAQAV" +
           "AAAAYmxhc3RmdXJuYWNlX2NoYXJ0Ml80AQGYAAAvAD+YAAAAAAYBAAAAAQAAAAkAAAABAf////8AAAAA" +
           "F2CJCgIAAAABABUAAABibGFzdGZ1cm5hY2VfY2hhcnQyXzUBAZkAAC8AP5kAAAAABgEAAAABAAAACQAA" +
           "AAEB/////wAAAAAXYIkKAgAAAAEAFQAAAGJsYXN0ZnVybmFjZV9jaGFydDJfNgEBmgAALwA/mgAAAAAG" +
           "AQAAAAEAAAAJAAAAAQH/////AAAAABdgiQoCAAAAAQAVAAAAYmxhc3RmdXJuYWNlX2NoYXJ0Ml83AQGb" +
           "AAAvAD+bAAAAAAYBAAAAAQAAAAkAAAABAf////8AAAAAF2CJCgIAAAABABUAAABibGFzdGZ1cm5hY2Vf" +
           "Y2hhcnQyXzgBAZwAAC8AP5wAAAAABgEAAAABAAAACQAAAAEB/////wAAAAAXYIkKAgAAAAEAFQAAAGJs" +
           "YXN0ZnVybmFjZV9jaGFydDNfMQEBnQAALwA/nQAAAAAGAQAAAAEAAAAJAAAAAQH/////AAAAABdgiQoC" +
           "AAAAAQAVAAAAYmxhc3RmdXJuYWNlX2NoYXJ0M18yAQGeAAAvAD+eAAAAAAYBAAAAAQAAAAkAAAABAf//" +
           "//8AAAAAF2CJCgIAAAABABUAAABibGFzdGZ1cm5hY2VfY2hhcnQzXzMBAZ8AAC8AP58AAAAABgEAAAAB" +
           "AAAACQAAAAEB/////wAAAAAXYIkKAgAAAAEAFQAAAGJsYXN0ZnVybmFjZV9jaGFydDRfMQEBoAAALwA/" +
           "oAAAAAAGAQAAAAEAAAAJAAAAAQH/////AAAAABdgiQoCAAAAAQAVAAAAYmxhc3RmdXJuYWNlX2NoYXJ0" +
           "NF8yAQGhAAAvAD+hAAAAAAYBAAAAAQAAAAkAAAABAf////8AAAAAF2CJCgIAAAABABUAAABibGFzdGZ1" +
           "cm5hY2VfY2hhcnQ0XzMBAaIAAC8AP6IAAAAABgEAAAABAAAACQAAAAEB/////wAAAAAXYIkKAgAAAAEA" +
           "FQAAAGJsYXN0ZnVybmFjZV9jaGFydDRfNAEBowAALwA/owAAAAAGAQAAAAEAAAAJAAAAAQH/////AAAA" +
           "AA==";
        #endregion
        #endif
        #endregion

        #region Public Properties
        /// <remarks />
        public AnalogUnitState<double> Temperature
        {
            get
            {
                return m_temperature;
            }

            set
            {
                if (!Object.ReferenceEquals(m_temperature, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_temperature = value;
            }
        }

        /// <remarks />
        public AnalogUnitState<double> Pressure
        {
            get
            {
                return m_pressure;
            }

            set
            {
                if (!Object.ReferenceEquals(m_pressure, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_pressure = value;
            }
        }

        /// <remarks />
        public MeasurementResetMethodState Reset
        {
            get
            {
                return m_resetMethod;
            }

            set
            {
                if (!Object.ReferenceEquals(m_resetMethod, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_resetMethod = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState<OrientationDataType> Orientation
        {
            get
            {
                return m_orientation;
            }

            set
            {
                if (!Object.ReferenceEquals(m_orientation, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_orientation = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState<double> Speed
        {
            get
            {
                return m_speed;
            }

            set
            {
                if (!Object.ReferenceEquals(m_speed, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_speed = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState ArrayTest
        {
            get
            {
                return m_arrayTest;
            }

            set
            {
                if (!Object.ReferenceEquals(m_arrayTest, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_arrayTest = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState<bool> BooleanTest
        {
            get
            {
                return m_booleanTest;
            }

            set
            {
                if (!Object.ReferenceEquals(m_booleanTest, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_booleanTest = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState<int> switch0
        {
            get
            {
                return m_switch0;
            }

            set
            {
                if (!Object.ReferenceEquals(m_switch0, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_switch0 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState<bool> switch1
        {
            get
            {
                return m_switch1;
            }

            set
            {
                if (!Object.ReferenceEquals(m_switch1, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_switch1 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState<bool> switch2
        {
            get
            {
                return m_switch2;
            }

            set
            {
                if (!Object.ReferenceEquals(m_switch2, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_switch2 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState<bool> switch3
        {
            get
            {
                return m_switch3;
            }

            set
            {
                if (!Object.ReferenceEquals(m_switch3, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_switch3 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState<bool> switch4
        {
            get
            {
                return m_switch4;
            }

            set
            {
                if (!Object.ReferenceEquals(m_switch4, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_switch4 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState<double> flowRateRT
        {
            get
            {
                return m_flowRateRT;
            }

            set
            {
                if (!Object.ReferenceEquals(m_flowRateRT, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_flowRateRT = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState<double> heatRT
        {
            get
            {
                return m_heatRT;
            }

            set
            {
                if (!Object.ReferenceEquals(m_heatRT, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_heatRT = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState<double> valveOpenRate
        {
            get
            {
                return m_valveOpenRate;
            }

            set
            {
                if (!Object.ReferenceEquals(m_valveOpenRate, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_valveOpenRate = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState<double> returnWaterPressure
        {
            get
            {
                return m_returnWaterPressure;
            }

            set
            {
                if (!Object.ReferenceEquals(m_returnWaterPressure, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_returnWaterPressure = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState<double> returnWaterTemp
        {
            get
            {
                return m_returnWaterTemp;
            }

            set
            {
                if (!Object.ReferenceEquals(m_returnWaterTemp, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_returnWaterTemp = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState<double> supplyWaterPressure
        {
            get
            {
                return m_supplyWaterPressure;
            }

            set
            {
                if (!Object.ReferenceEquals(m_supplyWaterPressure, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_supplyWaterPressure = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState<double> supplyWaterTemp
        {
            get
            {
                return m_supplyWaterTemp;
            }

            set
            {
                if (!Object.ReferenceEquals(m_supplyWaterTemp, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_supplyWaterTemp = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState<double> pumpFreq1
        {
            get
            {
                return m_pumpFreq1;
            }

            set
            {
                if (!Object.ReferenceEquals(m_pumpFreq1, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_pumpFreq1 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState<double> returnWaterPressure2
        {
            get
            {
                return m_returnWaterPressure2;
            }

            set
            {
                if (!Object.ReferenceEquals(m_returnWaterPressure2, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_returnWaterPressure2 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState<double> returnWaterTemp2
        {
            get
            {
                return m_returnWaterTemp2;
            }

            set
            {
                if (!Object.ReferenceEquals(m_returnWaterTemp2, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_returnWaterTemp2 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState<double> flowRateRT2
        {
            get
            {
                return m_flowRateRT2;
            }

            set
            {
                if (!Object.ReferenceEquals(m_flowRateRT2, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_flowRateRT2 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState<double> heatRT2
        {
            get
            {
                return m_heatRT2;
            }

            set
            {
                if (!Object.ReferenceEquals(m_heatRT2, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_heatRT2 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState<double> filterPressureDiff
        {
            get
            {
                return m_filterPressureDiff;
            }

            set
            {
                if (!Object.ReferenceEquals(m_filterPressureDiff, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_filterPressureDiff = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState<double> supplyWaterPressure2
        {
            get
            {
                return m_supplyWaterPressure2;
            }

            set
            {
                if (!Object.ReferenceEquals(m_supplyWaterPressure2, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_supplyWaterPressure2 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState<double> supplyWaterTemp2
        {
            get
            {
                return m_supplyWaterTemp2;
            }

            set
            {
                if (!Object.ReferenceEquals(m_supplyWaterTemp2, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_supplyWaterTemp2 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState<double> supplyWaterPressure3
        {
            get
            {
                return m_supplyWaterPressure3;
            }

            set
            {
                if (!Object.ReferenceEquals(m_supplyWaterPressure3, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_supplyWaterPressure3 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState<double> supplyWaterTemp3
        {
            get
            {
                return m_supplyWaterTemp3;
            }

            set
            {
                if (!Object.ReferenceEquals(m_supplyWaterTemp3, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_supplyWaterTemp3 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState<double> pumpFreq2
        {
            get
            {
                return m_pumpFreq2;
            }

            set
            {
                if (!Object.ReferenceEquals(m_pumpFreq2, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_pumpFreq2 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState<double> pumpFreq3
        {
            get
            {
                return m_pumpFreq3;
            }

            set
            {
                if (!Object.ReferenceEquals(m_pumpFreq3, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_pumpFreq3 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState<double> pumpFreq4
        {
            get
            {
                return m_pumpFreq4;
            }

            set
            {
                if (!Object.ReferenceEquals(m_pumpFreq4, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_pumpFreq4 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState<double> returnWaterPressure3
        {
            get
            {
                return m_returnWaterPressure3;
            }

            set
            {
                if (!Object.ReferenceEquals(m_returnWaterPressure3, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_returnWaterPressure3 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState<double> returnWaterTemp3
        {
            get
            {
                return m_returnWaterTemp3;
            }

            set
            {
                if (!Object.ReferenceEquals(m_returnWaterTemp3, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_returnWaterTemp3 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState<double> filterPressureDiff2
        {
            get
            {
                return m_filterPressureDiff2;
            }

            set
            {
                if (!Object.ReferenceEquals(m_filterPressureDiff2, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_filterPressureDiff2 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState<double> flowRateRT3
        {
            get
            {
                return m_flowRateRT3;
            }

            set
            {
                if (!Object.ReferenceEquals(m_flowRateRT3, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_flowRateRT3 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState<double> heatRT3
        {
            get
            {
                return m_heatRT3;
            }

            set
            {
                if (!Object.ReferenceEquals(m_heatRT3, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_heatRT3 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState<double> filterPressureDiff3
        {
            get
            {
                return m_filterPressureDiff3;
            }

            set
            {
                if (!Object.ReferenceEquals(m_filterPressureDiff3, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_filterPressureDiff3 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState<double> flowRateRT4
        {
            get
            {
                return m_flowRateRT4;
            }

            set
            {
                if (!Object.ReferenceEquals(m_flowRateRT4, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_flowRateRT4 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState<double> heatRT4
        {
            get
            {
                return m_heatRT4;
            }

            set
            {
                if (!Object.ReferenceEquals(m_heatRT4, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_heatRT4 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState<double> flowRateRT5
        {
            get
            {
                return m_flowRateRT5;
            }

            set
            {
                if (!Object.ReferenceEquals(m_flowRateRT5, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_flowRateRT5 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState<double> heatRT5
        {
            get
            {
                return m_heatRT5;
            }

            set
            {
                if (!Object.ReferenceEquals(m_heatRT5, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_heatRT5 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState<double> flowRateRT6
        {
            get
            {
                return m_flowRateRT6;
            }

            set
            {
                if (!Object.ReferenceEquals(m_flowRateRT6, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_flowRateRT6 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState<double> heatRT6
        {
            get
            {
                return m_heatRT6;
            }

            set
            {
                if (!Object.ReferenceEquals(m_heatRT6, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_heatRT6 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState<double> valveOpenRate2
        {
            get
            {
                return m_valveOpenRate2;
            }

            set
            {
                if (!Object.ReferenceEquals(m_valveOpenRate2, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_valveOpenRate2 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState<double> tankLevel
        {
            get
            {
                return m_tankLevel;
            }

            set
            {
                if (!Object.ReferenceEquals(m_tankLevel, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_tankLevel = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState<double> flowRateRT7
        {
            get
            {
                return m_flowRateRT7;
            }

            set
            {
                if (!Object.ReferenceEquals(m_flowRateRT7, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_flowRateRT7 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState<double> heatRT7
        {
            get
            {
                return m_heatRT7;
            }

            set
            {
                if (!Object.ReferenceEquals(m_heatRT7, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_heatRT7 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState<double> waterLevel
        {
            get
            {
                return m_waterLevel;
            }

            set
            {
                if (!Object.ReferenceEquals(m_waterLevel, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_waterLevel = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState heat_chart1
        {
            get
            {
                return m_heat_chart1;
            }

            set
            {
                if (!Object.ReferenceEquals(m_heat_chart1, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_heat_chart1 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState heat_chart2
        {
            get
            {
                return m_heat_chart2;
            }

            set
            {
                if (!Object.ReferenceEquals(m_heat_chart2, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_heat_chart2 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState heat_chart3_1
        {
            get
            {
                return m_heat_chart3_1;
            }

            set
            {
                if (!Object.ReferenceEquals(m_heat_chart3_1, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_heat_chart3_1 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState heat_chart3_2
        {
            get
            {
                return m_heat_chart3_2;
            }

            set
            {
                if (!Object.ReferenceEquals(m_heat_chart3_2, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_heat_chart3_2 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState heat_chart4_1
        {
            get
            {
                return m_heat_chart4_1;
            }

            set
            {
                if (!Object.ReferenceEquals(m_heat_chart4_1, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_heat_chart4_1 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState heat_chart4_2
        {
            get
            {
                return m_heat_chart4_2;
            }

            set
            {
                if (!Object.ReferenceEquals(m_heat_chart4_2, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_heat_chart4_2 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState heat_chart4_3
        {
            get
            {
                return m_heat_chart4_3;
            }

            set
            {
                if (!Object.ReferenceEquals(m_heat_chart4_3, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_heat_chart4_3 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState heat_chart4_4
        {
            get
            {
                return m_heat_chart4_4;
            }

            set
            {
                if (!Object.ReferenceEquals(m_heat_chart4_4, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_heat_chart4_4 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState<double> yearPlan1
        {
            get
            {
                return m_yearPlan1;
            }

            set
            {
                if (!Object.ReferenceEquals(m_yearPlan1, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_yearPlan1 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState<double> yearPlan2
        {
            get
            {
                return m_yearPlan2;
            }

            set
            {
                if (!Object.ReferenceEquals(m_yearPlan2, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_yearPlan2 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState<double> yearPlan3
        {
            get
            {
                return m_yearPlan3;
            }

            set
            {
                if (!Object.ReferenceEquals(m_yearPlan3, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_yearPlan3 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState<double> monthPlan1
        {
            get
            {
                return m_monthPlan1;
            }

            set
            {
                if (!Object.ReferenceEquals(m_monthPlan1, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_monthPlan1 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState<double> monthPlan2
        {
            get
            {
                return m_monthPlan2;
            }

            set
            {
                if (!Object.ReferenceEquals(m_monthPlan2, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_monthPlan2 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState<double> monthPlan3
        {
            get
            {
                return m_monthPlan3;
            }

            set
            {
                if (!Object.ReferenceEquals(m_monthPlan3, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_monthPlan3 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState<double> monthPlan4
        {
            get
            {
                return m_monthPlan4;
            }

            set
            {
                if (!Object.ReferenceEquals(m_monthPlan4, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_monthPlan4 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState<double> dayPlan1
        {
            get
            {
                return m_dayPlan1;
            }

            set
            {
                if (!Object.ReferenceEquals(m_dayPlan1, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_dayPlan1 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState<double> dayPlan2
        {
            get
            {
                return m_dayPlan2;
            }

            set
            {
                if (!Object.ReferenceEquals(m_dayPlan2, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_dayPlan2 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState<double> dayPlan3
        {
            get
            {
                return m_dayPlan3;
            }

            set
            {
                if (!Object.ReferenceEquals(m_dayPlan3, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_dayPlan3 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState<double> dayPlan4
        {
            get
            {
                return m_dayPlan4;
            }

            set
            {
                if (!Object.ReferenceEquals(m_dayPlan4, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_dayPlan4 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState<double> storeData1
        {
            get
            {
                return m_storeData1;
            }

            set
            {
                if (!Object.ReferenceEquals(m_storeData1, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_storeData1 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState<double> storeData2
        {
            get
            {
                return m_storeData2;
            }

            set
            {
                if (!Object.ReferenceEquals(m_storeData2, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_storeData2 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState<double> storeData3
        {
            get
            {
                return m_storeData3;
            }

            set
            {
                if (!Object.ReferenceEquals(m_storeData3, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_storeData3 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState meter_chart1_1
        {
            get
            {
                return m_meter_chart1_1;
            }

            set
            {
                if (!Object.ReferenceEquals(m_meter_chart1_1, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_meter_chart1_1 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState meter_chart1_2
        {
            get
            {
                return m_meter_chart1_2;
            }

            set
            {
                if (!Object.ReferenceEquals(m_meter_chart1_2, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_meter_chart1_2 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState meter_chart2_1
        {
            get
            {
                return m_meter_chart2_1;
            }

            set
            {
                if (!Object.ReferenceEquals(m_meter_chart2_1, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_meter_chart2_1 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState meter_chart2_2
        {
            get
            {
                return m_meter_chart2_2;
            }

            set
            {
                if (!Object.ReferenceEquals(m_meter_chart2_2, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_meter_chart2_2 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState meter_chart3_1
        {
            get
            {
                return m_meter_chart3_1;
            }

            set
            {
                if (!Object.ReferenceEquals(m_meter_chart3_1, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_meter_chart3_1 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState meter_chart3_2
        {
            get
            {
                return m_meter_chart3_2;
            }

            set
            {
                if (!Object.ReferenceEquals(m_meter_chart3_2, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_meter_chart3_2 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState meter_table
        {
            get
            {
                return m_meter_table;
            }

            set
            {
                if (!Object.ReferenceEquals(m_meter_table, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_meter_table = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState temperatures
        {
            get
            {
                return m_temperatures;
            }

            set
            {
                if (!Object.ReferenceEquals(m_temperatures, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_temperatures = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState pressures
        {
            get
            {
                return m_pressures;
            }

            set
            {
                if (!Object.ReferenceEquals(m_pressures, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_pressures = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState furnace_chart1_1
        {
            get
            {
                return m_furnace_chart1_1;
            }

            set
            {
                if (!Object.ReferenceEquals(m_furnace_chart1_1, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_furnace_chart1_1 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState furnace_chart1_2
        {
            get
            {
                return m_furnace_chart1_2;
            }

            set
            {
                if (!Object.ReferenceEquals(m_furnace_chart1_2, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_furnace_chart1_2 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState furnace_chart2_1
        {
            get
            {
                return m_furnace_chart2_1;
            }

            set
            {
                if (!Object.ReferenceEquals(m_furnace_chart2_1, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_furnace_chart2_1 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState furnace_chart2_2
        {
            get
            {
                return m_furnace_chart2_2;
            }

            set
            {
                if (!Object.ReferenceEquals(m_furnace_chart2_2, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_furnace_chart2_2 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState blastfurnace_energy
        {
            get
            {
                return m_blastfurnace_energy;
            }

            set
            {
                if (!Object.ReferenceEquals(m_blastfurnace_energy, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_blastfurnace_energy = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState blastfurnace_yield
        {
            get
            {
                return m_blastfurnace_yield;
            }

            set
            {
                if (!Object.ReferenceEquals(m_blastfurnace_yield, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_blastfurnace_yield = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState blastfurnace_condition
        {
            get
            {
                return m_blastfurnace_condition;
            }

            set
            {
                if (!Object.ReferenceEquals(m_blastfurnace_condition, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_blastfurnace_condition = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState blastfurnace_chart1_1
        {
            get
            {
                return m_blastfurnace_chart1_1;
            }

            set
            {
                if (!Object.ReferenceEquals(m_blastfurnace_chart1_1, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_blastfurnace_chart1_1 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState blastfurnace_chart1_2
        {
            get
            {
                return m_blastfurnace_chart1_2;
            }

            set
            {
                if (!Object.ReferenceEquals(m_blastfurnace_chart1_2, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_blastfurnace_chart1_2 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState blastfurnace_chart2_1
        {
            get
            {
                return m_blastfurnace_chart2_1;
            }

            set
            {
                if (!Object.ReferenceEquals(m_blastfurnace_chart2_1, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_blastfurnace_chart2_1 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState blastfurnace_chart2_2
        {
            get
            {
                return m_blastfurnace_chart2_2;
            }

            set
            {
                if (!Object.ReferenceEquals(m_blastfurnace_chart2_2, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_blastfurnace_chart2_2 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState blastfurnace_chart2_3
        {
            get
            {
                return m_blastfurnace_chart2_3;
            }

            set
            {
                if (!Object.ReferenceEquals(m_blastfurnace_chart2_3, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_blastfurnace_chart2_3 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState blastfurnace_chart2_4
        {
            get
            {
                return m_blastfurnace_chart2_4;
            }

            set
            {
                if (!Object.ReferenceEquals(m_blastfurnace_chart2_4, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_blastfurnace_chart2_4 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState blastfurnace_chart2_5
        {
            get
            {
                return m_blastfurnace_chart2_5;
            }

            set
            {
                if (!Object.ReferenceEquals(m_blastfurnace_chart2_5, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_blastfurnace_chart2_5 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState blastfurnace_chart2_6
        {
            get
            {
                return m_blastfurnace_chart2_6;
            }

            set
            {
                if (!Object.ReferenceEquals(m_blastfurnace_chart2_6, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_blastfurnace_chart2_6 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState blastfurnace_chart2_7
        {
            get
            {
                return m_blastfurnace_chart2_7;
            }

            set
            {
                if (!Object.ReferenceEquals(m_blastfurnace_chart2_7, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_blastfurnace_chart2_7 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState blastfurnace_chart2_8
        {
            get
            {
                return m_blastfurnace_chart2_8;
            }

            set
            {
                if (!Object.ReferenceEquals(m_blastfurnace_chart2_8, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_blastfurnace_chart2_8 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState blastfurnace_chart3_1
        {
            get
            {
                return m_blastfurnace_chart3_1;
            }

            set
            {
                if (!Object.ReferenceEquals(m_blastfurnace_chart3_1, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_blastfurnace_chart3_1 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState blastfurnace_chart3_2
        {
            get
            {
                return m_blastfurnace_chart3_2;
            }

            set
            {
                if (!Object.ReferenceEquals(m_blastfurnace_chart3_2, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_blastfurnace_chart3_2 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState blastfurnace_chart3_3
        {
            get
            {
                return m_blastfurnace_chart3_3;
            }

            set
            {
                if (!Object.ReferenceEquals(m_blastfurnace_chart3_3, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_blastfurnace_chart3_3 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState blastfurnace_chart4_1
        {
            get
            {
                return m_blastfurnace_chart4_1;
            }

            set
            {
                if (!Object.ReferenceEquals(m_blastfurnace_chart4_1, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_blastfurnace_chart4_1 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState blastfurnace_chart4_2
        {
            get
            {
                return m_blastfurnace_chart4_2;
            }

            set
            {
                if (!Object.ReferenceEquals(m_blastfurnace_chart4_2, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_blastfurnace_chart4_2 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState blastfurnace_chart4_3
        {
            get
            {
                return m_blastfurnace_chart4_3;
            }

            set
            {
                if (!Object.ReferenceEquals(m_blastfurnace_chart4_3, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_blastfurnace_chart4_3 = value;
            }
        }

        /// <remarks />
        public BaseDataVariableState blastfurnace_chart4_4
        {
            get
            {
                return m_blastfurnace_chart4_4;
            }

            set
            {
                if (!Object.ReferenceEquals(m_blastfurnace_chart4_4, value))
                {
                    ChangeMasks |= NodeStateChangeMasks.Children;
                }

                m_blastfurnace_chart4_4 = value;
            }
        }
        #endregion

        #region Overridden Methods
        /// <remarks />
        public override void GetChildren(
            ISystemContext context,
            IList<BaseInstanceState> children)
        {
            if (m_temperature != null)
            {
                children.Add(m_temperature);
            }

            if (m_pressure != null)
            {
                children.Add(m_pressure);
            }

            if (m_resetMethod != null)
            {
                children.Add(m_resetMethod);
            }

            if (m_orientation != null)
            {
                children.Add(m_orientation);
            }

            if (m_speed != null)
            {
                children.Add(m_speed);
            }

            if (m_arrayTest != null)
            {
                children.Add(m_arrayTest);
            }

            if (m_booleanTest != null)
            {
                children.Add(m_booleanTest);
            }

            if (m_switch0 != null)
            {
                children.Add(m_switch0);
            }

            if (m_switch1 != null)
            {
                children.Add(m_switch1);
            }

            if (m_switch2 != null)
            {
                children.Add(m_switch2);
            }

            if (m_switch3 != null)
            {
                children.Add(m_switch3);
            }

            if (m_switch4 != null)
            {
                children.Add(m_switch4);
            }

            if (m_flowRateRT != null)
            {
                children.Add(m_flowRateRT);
            }

            if (m_heatRT != null)
            {
                children.Add(m_heatRT);
            }

            if (m_valveOpenRate != null)
            {
                children.Add(m_valveOpenRate);
            }

            if (m_returnWaterPressure != null)
            {
                children.Add(m_returnWaterPressure);
            }

            if (m_returnWaterTemp != null)
            {
                children.Add(m_returnWaterTemp);
            }

            if (m_supplyWaterPressure != null)
            {
                children.Add(m_supplyWaterPressure);
            }

            if (m_supplyWaterTemp != null)
            {
                children.Add(m_supplyWaterTemp);
            }

            if (m_pumpFreq1 != null)
            {
                children.Add(m_pumpFreq1);
            }

            if (m_returnWaterPressure2 != null)
            {
                children.Add(m_returnWaterPressure2);
            }

            if (m_returnWaterTemp2 != null)
            {
                children.Add(m_returnWaterTemp2);
            }

            if (m_flowRateRT2 != null)
            {
                children.Add(m_flowRateRT2);
            }

            if (m_heatRT2 != null)
            {
                children.Add(m_heatRT2);
            }

            if (m_filterPressureDiff != null)
            {
                children.Add(m_filterPressureDiff);
            }

            if (m_supplyWaterPressure2 != null)
            {
                children.Add(m_supplyWaterPressure2);
            }

            if (m_supplyWaterTemp2 != null)
            {
                children.Add(m_supplyWaterTemp2);
            }

            if (m_supplyWaterPressure3 != null)
            {
                children.Add(m_supplyWaterPressure3);
            }

            if (m_supplyWaterTemp3 != null)
            {
                children.Add(m_supplyWaterTemp3);
            }

            if (m_pumpFreq2 != null)
            {
                children.Add(m_pumpFreq2);
            }

            if (m_pumpFreq3 != null)
            {
                children.Add(m_pumpFreq3);
            }

            if (m_pumpFreq4 != null)
            {
                children.Add(m_pumpFreq4);
            }

            if (m_returnWaterPressure3 != null)
            {
                children.Add(m_returnWaterPressure3);
            }

            if (m_returnWaterTemp3 != null)
            {
                children.Add(m_returnWaterTemp3);
            }

            if (m_filterPressureDiff2 != null)
            {
                children.Add(m_filterPressureDiff2);
            }

            if (m_flowRateRT3 != null)
            {
                children.Add(m_flowRateRT3);
            }

            if (m_heatRT3 != null)
            {
                children.Add(m_heatRT3);
            }

            if (m_filterPressureDiff3 != null)
            {
                children.Add(m_filterPressureDiff3);
            }

            if (m_flowRateRT4 != null)
            {
                children.Add(m_flowRateRT4);
            }

            if (m_heatRT4 != null)
            {
                children.Add(m_heatRT4);
            }

            if (m_flowRateRT5 != null)
            {
                children.Add(m_flowRateRT5);
            }

            if (m_heatRT5 != null)
            {
                children.Add(m_heatRT5);
            }

            if (m_flowRateRT6 != null)
            {
                children.Add(m_flowRateRT6);
            }

            if (m_heatRT6 != null)
            {
                children.Add(m_heatRT6);
            }

            if (m_valveOpenRate2 != null)
            {
                children.Add(m_valveOpenRate2);
            }

            if (m_tankLevel != null)
            {
                children.Add(m_tankLevel);
            }

            if (m_flowRateRT7 != null)
            {
                children.Add(m_flowRateRT7);
            }

            if (m_heatRT7 != null)
            {
                children.Add(m_heatRT7);
            }

            if (m_waterLevel != null)
            {
                children.Add(m_waterLevel);
            }

            if (m_heat_chart1 != null)
            {
                children.Add(m_heat_chart1);
            }

            if (m_heat_chart2 != null)
            {
                children.Add(m_heat_chart2);
            }

            if (m_heat_chart3_1 != null)
            {
                children.Add(m_heat_chart3_1);
            }

            if (m_heat_chart3_2 != null)
            {
                children.Add(m_heat_chart3_2);
            }

            if (m_heat_chart4_1 != null)
            {
                children.Add(m_heat_chart4_1);
            }

            if (m_heat_chart4_2 != null)
            {
                children.Add(m_heat_chart4_2);
            }

            if (m_heat_chart4_3 != null)
            {
                children.Add(m_heat_chart4_3);
            }

            if (m_heat_chart4_4 != null)
            {
                children.Add(m_heat_chart4_4);
            }

            if (m_yearPlan1 != null)
            {
                children.Add(m_yearPlan1);
            }

            if (m_yearPlan2 != null)
            {
                children.Add(m_yearPlan2);
            }

            if (m_yearPlan3 != null)
            {
                children.Add(m_yearPlan3);
            }

            if (m_monthPlan1 != null)
            {
                children.Add(m_monthPlan1);
            }

            if (m_monthPlan2 != null)
            {
                children.Add(m_monthPlan2);
            }

            if (m_monthPlan3 != null)
            {
                children.Add(m_monthPlan3);
            }

            if (m_monthPlan4 != null)
            {
                children.Add(m_monthPlan4);
            }

            if (m_dayPlan1 != null)
            {
                children.Add(m_dayPlan1);
            }

            if (m_dayPlan2 != null)
            {
                children.Add(m_dayPlan2);
            }

            if (m_dayPlan3 != null)
            {
                children.Add(m_dayPlan3);
            }

            if (m_dayPlan4 != null)
            {
                children.Add(m_dayPlan4);
            }

            if (m_storeData1 != null)
            {
                children.Add(m_storeData1);
            }

            if (m_storeData2 != null)
            {
                children.Add(m_storeData2);
            }

            if (m_storeData3 != null)
            {
                children.Add(m_storeData3);
            }

            if (m_meter_chart1_1 != null)
            {
                children.Add(m_meter_chart1_1);
            }

            if (m_meter_chart1_2 != null)
            {
                children.Add(m_meter_chart1_2);
            }

            if (m_meter_chart2_1 != null)
            {
                children.Add(m_meter_chart2_1);
            }

            if (m_meter_chart2_2 != null)
            {
                children.Add(m_meter_chart2_2);
            }

            if (m_meter_chart3_1 != null)
            {
                children.Add(m_meter_chart3_1);
            }

            if (m_meter_chart3_2 != null)
            {
                children.Add(m_meter_chart3_2);
            }

            if (m_meter_table != null)
            {
                children.Add(m_meter_table);
            }

            if (m_temperatures != null)
            {
                children.Add(m_temperatures);
            }

            if (m_pressures != null)
            {
                children.Add(m_pressures);
            }

            if (m_furnace_chart1_1 != null)
            {
                children.Add(m_furnace_chart1_1);
            }

            if (m_furnace_chart1_2 != null)
            {
                children.Add(m_furnace_chart1_2);
            }

            if (m_furnace_chart2_1 != null)
            {
                children.Add(m_furnace_chart2_1);
            }

            if (m_furnace_chart2_2 != null)
            {
                children.Add(m_furnace_chart2_2);
            }

            if (m_blastfurnace_energy != null)
            {
                children.Add(m_blastfurnace_energy);
            }

            if (m_blastfurnace_yield != null)
            {
                children.Add(m_blastfurnace_yield);
            }

            if (m_blastfurnace_condition != null)
            {
                children.Add(m_blastfurnace_condition);
            }

            if (m_blastfurnace_chart1_1 != null)
            {
                children.Add(m_blastfurnace_chart1_1);
            }

            if (m_blastfurnace_chart1_2 != null)
            {
                children.Add(m_blastfurnace_chart1_2);
            }

            if (m_blastfurnace_chart2_1 != null)
            {
                children.Add(m_blastfurnace_chart2_1);
            }

            if (m_blastfurnace_chart2_2 != null)
            {
                children.Add(m_blastfurnace_chart2_2);
            }

            if (m_blastfurnace_chart2_3 != null)
            {
                children.Add(m_blastfurnace_chart2_3);
            }

            if (m_blastfurnace_chart2_4 != null)
            {
                children.Add(m_blastfurnace_chart2_4);
            }

            if (m_blastfurnace_chart2_5 != null)
            {
                children.Add(m_blastfurnace_chart2_5);
            }

            if (m_blastfurnace_chart2_6 != null)
            {
                children.Add(m_blastfurnace_chart2_6);
            }

            if (m_blastfurnace_chart2_7 != null)
            {
                children.Add(m_blastfurnace_chart2_7);
            }

            if (m_blastfurnace_chart2_8 != null)
            {
                children.Add(m_blastfurnace_chart2_8);
            }

            if (m_blastfurnace_chart3_1 != null)
            {
                children.Add(m_blastfurnace_chart3_1);
            }

            if (m_blastfurnace_chart3_2 != null)
            {
                children.Add(m_blastfurnace_chart3_2);
            }

            if (m_blastfurnace_chart3_3 != null)
            {
                children.Add(m_blastfurnace_chart3_3);
            }

            if (m_blastfurnace_chart4_1 != null)
            {
                children.Add(m_blastfurnace_chart4_1);
            }

            if (m_blastfurnace_chart4_2 != null)
            {
                children.Add(m_blastfurnace_chart4_2);
            }

            if (m_blastfurnace_chart4_3 != null)
            {
                children.Add(m_blastfurnace_chart4_3);
            }

            if (m_blastfurnace_chart4_4 != null)
            {
                children.Add(m_blastfurnace_chart4_4);
            }

            base.GetChildren(context, children);
        }
            
        /// <remarks />
        protected override BaseInstanceState FindChild(
            ISystemContext context,
            QualifiedName browseName,
            bool createOrReplace,
            BaseInstanceState replacement)
        {
            if (QualifiedName.IsNull(browseName))
            {
                return null;
            }

            BaseInstanceState instance = null;

            switch (browseName.Name)
            {
                case Measurements.BrowseNames.Temperature:
                {
                    if (createOrReplace)
                    {
                        if (Temperature == null)
                        {
                            if (replacement == null)
                            {
                                Temperature = new AnalogUnitState<double>(this);
                            }
                            else
                            {
                                Temperature = (AnalogUnitState<double>)replacement;
                            }
                        }
                    }

                    instance = Temperature;
                    break;
                }

                case Measurements.BrowseNames.Pressure:
                {
                    if (createOrReplace)
                    {
                        if (Pressure == null)
                        {
                            if (replacement == null)
                            {
                                Pressure = new AnalogUnitState<double>(this);
                            }
                            else
                            {
                                Pressure = (AnalogUnitState<double>)replacement;
                            }
                        }
                    }

                    instance = Pressure;
                    break;
                }

                case Measurements.BrowseNames.Reset:
                {
                    if (createOrReplace)
                    {
                        if (Reset == null)
                        {
                            if (replacement == null)
                            {
                                Reset = new MeasurementResetMethodState(this);
                            }
                            else
                            {
                                Reset = (MeasurementResetMethodState)replacement;
                            }
                        }
                    }

                    instance = Reset;
                    break;
                }

                case Measurements.BrowseNames.Orientation:
                {
                    if (createOrReplace)
                    {
                        if (Orientation == null)
                        {
                            if (replacement == null)
                            {
                                Orientation = new BaseDataVariableState<OrientationDataType>(this);
                            }
                            else
                            {
                                Orientation = (BaseDataVariableState<OrientationDataType>)replacement;
                            }
                        }
                    }

                    instance = Orientation;
                    break;
                }

                case Measurements.BrowseNames.Speed:
                {
                    if (createOrReplace)
                    {
                        if (Speed == null)
                        {
                            if (replacement == null)
                            {
                                Speed = new BaseDataVariableState<double>(this);
                            }
                            else
                            {
                                Speed = (BaseDataVariableState<double>)replacement;
                            }
                        }
                    }

                    instance = Speed;
                    break;
                }

                case Measurements.BrowseNames.ArrayTest:
                {
                    if (createOrReplace)
                    {
                        if (ArrayTest == null)
                        {
                            if (replacement == null)
                            {
                                ArrayTest = new BaseDataVariableState(this);
                            }
                            else
                            {
                                ArrayTest = (BaseDataVariableState)replacement;
                            }
                        }
                    }

                    instance = ArrayTest;
                    break;
                }

                case Measurements.BrowseNames.BooleanTest:
                {
                    if (createOrReplace)
                    {
                        if (BooleanTest == null)
                        {
                            if (replacement == null)
                            {
                                BooleanTest = new BaseDataVariableState<bool>(this);
                            }
                            else
                            {
                                BooleanTest = (BaseDataVariableState<bool>)replacement;
                            }
                        }
                    }

                    instance = BooleanTest;
                    break;
                }

                case Measurements.BrowseNames.switch0:
                {
                    if (createOrReplace)
                    {
                        if (switch0 == null)
                        {
                            if (replacement == null)
                            {
                                switch0 = new BaseDataVariableState<int>(this);
                            }
                            else
                            {
                                switch0 = (BaseDataVariableState<int>)replacement;
                            }
                        }
                    }

                    instance = switch0;
                    break;
                }

                case Measurements.BrowseNames.switch1:
                {
                    if (createOrReplace)
                    {
                        if (switch1 == null)
                        {
                            if (replacement == null)
                            {
                                switch1 = new BaseDataVariableState<bool>(this);
                            }
                            else
                            {
                                switch1 = (BaseDataVariableState<bool>)replacement;
                            }
                        }
                    }

                    instance = switch1;
                    break;
                }

                case Measurements.BrowseNames.switch2:
                {
                    if (createOrReplace)
                    {
                        if (switch2 == null)
                        {
                            if (replacement == null)
                            {
                                switch2 = new BaseDataVariableState<bool>(this);
                            }
                            else
                            {
                                switch2 = (BaseDataVariableState<bool>)replacement;
                            }
                        }
                    }

                    instance = switch2;
                    break;
                }

                case Measurements.BrowseNames.switch3:
                {
                    if (createOrReplace)
                    {
                        if (switch3 == null)
                        {
                            if (replacement == null)
                            {
                                switch3 = new BaseDataVariableState<bool>(this);
                            }
                            else
                            {
                                switch3 = (BaseDataVariableState<bool>)replacement;
                            }
                        }
                    }

                    instance = switch3;
                    break;
                }

                case Measurements.BrowseNames.switch4:
                {
                    if (createOrReplace)
                    {
                        if (switch4 == null)
                        {
                            if (replacement == null)
                            {
                                switch4 = new BaseDataVariableState<bool>(this);
                            }
                            else
                            {
                                switch4 = (BaseDataVariableState<bool>)replacement;
                            }
                        }
                    }

                    instance = switch4;
                    break;
                }

                case Measurements.BrowseNames.flowRateRT:
                {
                    if (createOrReplace)
                    {
                        if (flowRateRT == null)
                        {
                            if (replacement == null)
                            {
                                flowRateRT = new BaseDataVariableState<double>(this);
                            }
                            else
                            {
                                flowRateRT = (BaseDataVariableState<double>)replacement;
                            }
                        }
                    }

                    instance = flowRateRT;
                    break;
                }

                case Measurements.BrowseNames.heatRT:
                {
                    if (createOrReplace)
                    {
                        if (heatRT == null)
                        {
                            if (replacement == null)
                            {
                                heatRT = new BaseDataVariableState<double>(this);
                            }
                            else
                            {
                                heatRT = (BaseDataVariableState<double>)replacement;
                            }
                        }
                    }

                    instance = heatRT;
                    break;
                }

                case Measurements.BrowseNames.valveOpenRate:
                {
                    if (createOrReplace)
                    {
                        if (valveOpenRate == null)
                        {
                            if (replacement == null)
                            {
                                valveOpenRate = new BaseDataVariableState<double>(this);
                            }
                            else
                            {
                                valveOpenRate = (BaseDataVariableState<double>)replacement;
                            }
                        }
                    }

                    instance = valveOpenRate;
                    break;
                }

                case Measurements.BrowseNames.returnWaterPressure:
                {
                    if (createOrReplace)
                    {
                        if (returnWaterPressure == null)
                        {
                            if (replacement == null)
                            {
                                returnWaterPressure = new BaseDataVariableState<double>(this);
                            }
                            else
                            {
                                returnWaterPressure = (BaseDataVariableState<double>)replacement;
                            }
                        }
                    }

                    instance = returnWaterPressure;
                    break;
                }

                case Measurements.BrowseNames.returnWaterTemp:
                {
                    if (createOrReplace)
                    {
                        if (returnWaterTemp == null)
                        {
                            if (replacement == null)
                            {
                                returnWaterTemp = new BaseDataVariableState<double>(this);
                            }
                            else
                            {
                                returnWaterTemp = (BaseDataVariableState<double>)replacement;
                            }
                        }
                    }

                    instance = returnWaterTemp;
                    break;
                }

                case Measurements.BrowseNames.supplyWaterPressure:
                {
                    if (createOrReplace)
                    {
                        if (supplyWaterPressure == null)
                        {
                            if (replacement == null)
                            {
                                supplyWaterPressure = new BaseDataVariableState<double>(this);
                            }
                            else
                            {
                                supplyWaterPressure = (BaseDataVariableState<double>)replacement;
                            }
                        }
                    }

                    instance = supplyWaterPressure;
                    break;
                }

                case Measurements.BrowseNames.supplyWaterTemp:
                {
                    if (createOrReplace)
                    {
                        if (supplyWaterTemp == null)
                        {
                            if (replacement == null)
                            {
                                supplyWaterTemp = new BaseDataVariableState<double>(this);
                            }
                            else
                            {
                                supplyWaterTemp = (BaseDataVariableState<double>)replacement;
                            }
                        }
                    }

                    instance = supplyWaterTemp;
                    break;
                }

                case Measurements.BrowseNames.pumpFreq1:
                {
                    if (createOrReplace)
                    {
                        if (pumpFreq1 == null)
                        {
                            if (replacement == null)
                            {
                                pumpFreq1 = new BaseDataVariableState<double>(this);
                            }
                            else
                            {
                                pumpFreq1 = (BaseDataVariableState<double>)replacement;
                            }
                        }
                    }

                    instance = pumpFreq1;
                    break;
                }

                case Measurements.BrowseNames.returnWaterPressure2:
                {
                    if (createOrReplace)
                    {
                        if (returnWaterPressure2 == null)
                        {
                            if (replacement == null)
                            {
                                returnWaterPressure2 = new BaseDataVariableState<double>(this);
                            }
                            else
                            {
                                returnWaterPressure2 = (BaseDataVariableState<double>)replacement;
                            }
                        }
                    }

                    instance = returnWaterPressure2;
                    break;
                }

                case Measurements.BrowseNames.returnWaterTemp2:
                {
                    if (createOrReplace)
                    {
                        if (returnWaterTemp2 == null)
                        {
                            if (replacement == null)
                            {
                                returnWaterTemp2 = new BaseDataVariableState<double>(this);
                            }
                            else
                            {
                                returnWaterTemp2 = (BaseDataVariableState<double>)replacement;
                            }
                        }
                    }

                    instance = returnWaterTemp2;
                    break;
                }

                case Measurements.BrowseNames.flowRateRT2:
                {
                    if (createOrReplace)
                    {
                        if (flowRateRT2 == null)
                        {
                            if (replacement == null)
                            {
                                flowRateRT2 = new BaseDataVariableState<double>(this);
                            }
                            else
                            {
                                flowRateRT2 = (BaseDataVariableState<double>)replacement;
                            }
                        }
                    }

                    instance = flowRateRT2;
                    break;
                }

                case Measurements.BrowseNames.heatRT2:
                {
                    if (createOrReplace)
                    {
                        if (heatRT2 == null)
                        {
                            if (replacement == null)
                            {
                                heatRT2 = new BaseDataVariableState<double>(this);
                            }
                            else
                            {
                                heatRT2 = (BaseDataVariableState<double>)replacement;
                            }
                        }
                    }

                    instance = heatRT2;
                    break;
                }

                case Measurements.BrowseNames.filterPressureDiff:
                {
                    if (createOrReplace)
                    {
                        if (filterPressureDiff == null)
                        {
                            if (replacement == null)
                            {
                                filterPressureDiff = new BaseDataVariableState<double>(this);
                            }
                            else
                            {
                                filterPressureDiff = (BaseDataVariableState<double>)replacement;
                            }
                        }
                    }

                    instance = filterPressureDiff;
                    break;
                }

                case Measurements.BrowseNames.supplyWaterPressure2:
                {
                    if (createOrReplace)
                    {
                        if (supplyWaterPressure2 == null)
                        {
                            if (replacement == null)
                            {
                                supplyWaterPressure2 = new BaseDataVariableState<double>(this);
                            }
                            else
                            {
                                supplyWaterPressure2 = (BaseDataVariableState<double>)replacement;
                            }
                        }
                    }

                    instance = supplyWaterPressure2;
                    break;
                }

                case Measurements.BrowseNames.supplyWaterTemp2:
                {
                    if (createOrReplace)
                    {
                        if (supplyWaterTemp2 == null)
                        {
                            if (replacement == null)
                            {
                                supplyWaterTemp2 = new BaseDataVariableState<double>(this);
                            }
                            else
                            {
                                supplyWaterTemp2 = (BaseDataVariableState<double>)replacement;
                            }
                        }
                    }

                    instance = supplyWaterTemp2;
                    break;
                }

                case Measurements.BrowseNames.supplyWaterPressure3:
                {
                    if (createOrReplace)
                    {
                        if (supplyWaterPressure3 == null)
                        {
                            if (replacement == null)
                            {
                                supplyWaterPressure3 = new BaseDataVariableState<double>(this);
                            }
                            else
                            {
                                supplyWaterPressure3 = (BaseDataVariableState<double>)replacement;
                            }
                        }
                    }

                    instance = supplyWaterPressure3;
                    break;
                }

                case Measurements.BrowseNames.supplyWaterTemp3:
                {
                    if (createOrReplace)
                    {
                        if (supplyWaterTemp3 == null)
                        {
                            if (replacement == null)
                            {
                                supplyWaterTemp3 = new BaseDataVariableState<double>(this);
                            }
                            else
                            {
                                supplyWaterTemp3 = (BaseDataVariableState<double>)replacement;
                            }
                        }
                    }

                    instance = supplyWaterTemp3;
                    break;
                }

                case Measurements.BrowseNames.pumpFreq2:
                {
                    if (createOrReplace)
                    {
                        if (pumpFreq2 == null)
                        {
                            if (replacement == null)
                            {
                                pumpFreq2 = new BaseDataVariableState<double>(this);
                            }
                            else
                            {
                                pumpFreq2 = (BaseDataVariableState<double>)replacement;
                            }
                        }
                    }

                    instance = pumpFreq2;
                    break;
                }

                case Measurements.BrowseNames.pumpFreq3:
                {
                    if (createOrReplace)
                    {
                        if (pumpFreq3 == null)
                        {
                            if (replacement == null)
                            {
                                pumpFreq3 = new BaseDataVariableState<double>(this);
                            }
                            else
                            {
                                pumpFreq3 = (BaseDataVariableState<double>)replacement;
                            }
                        }
                    }

                    instance = pumpFreq3;
                    break;
                }

                case Measurements.BrowseNames.pumpFreq4:
                {
                    if (createOrReplace)
                    {
                        if (pumpFreq4 == null)
                        {
                            if (replacement == null)
                            {
                                pumpFreq4 = new BaseDataVariableState<double>(this);
                            }
                            else
                            {
                                pumpFreq4 = (BaseDataVariableState<double>)replacement;
                            }
                        }
                    }

                    instance = pumpFreq4;
                    break;
                }

                case Measurements.BrowseNames.returnWaterPressure3:
                {
                    if (createOrReplace)
                    {
                        if (returnWaterPressure3 == null)
                        {
                            if (replacement == null)
                            {
                                returnWaterPressure3 = new BaseDataVariableState<double>(this);
                            }
                            else
                            {
                                returnWaterPressure3 = (BaseDataVariableState<double>)replacement;
                            }
                        }
                    }

                    instance = returnWaterPressure3;
                    break;
                }

                case Measurements.BrowseNames.returnWaterTemp3:
                {
                    if (createOrReplace)
                    {
                        if (returnWaterTemp3 == null)
                        {
                            if (replacement == null)
                            {
                                returnWaterTemp3 = new BaseDataVariableState<double>(this);
                            }
                            else
                            {
                                returnWaterTemp3 = (BaseDataVariableState<double>)replacement;
                            }
                        }
                    }

                    instance = returnWaterTemp3;
                    break;
                }

                case Measurements.BrowseNames.filterPressureDiff2:
                {
                    if (createOrReplace)
                    {
                        if (filterPressureDiff2 == null)
                        {
                            if (replacement == null)
                            {
                                filterPressureDiff2 = new BaseDataVariableState<double>(this);
                            }
                            else
                            {
                                filterPressureDiff2 = (BaseDataVariableState<double>)replacement;
                            }
                        }
                    }

                    instance = filterPressureDiff2;
                    break;
                }

                case Measurements.BrowseNames.flowRateRT3:
                {
                    if (createOrReplace)
                    {
                        if (flowRateRT3 == null)
                        {
                            if (replacement == null)
                            {
                                flowRateRT3 = new BaseDataVariableState<double>(this);
                            }
                            else
                            {
                                flowRateRT3 = (BaseDataVariableState<double>)replacement;
                            }
                        }
                    }

                    instance = flowRateRT3;
                    break;
                }

                case Measurements.BrowseNames.heatRT3:
                {
                    if (createOrReplace)
                    {
                        if (heatRT3 == null)
                        {
                            if (replacement == null)
                            {
                                heatRT3 = new BaseDataVariableState<double>(this);
                            }
                            else
                            {
                                heatRT3 = (BaseDataVariableState<double>)replacement;
                            }
                        }
                    }

                    instance = heatRT3;
                    break;
                }

                case Measurements.BrowseNames.filterPressureDiff3:
                {
                    if (createOrReplace)
                    {
                        if (filterPressureDiff3 == null)
                        {
                            if (replacement == null)
                            {
                                filterPressureDiff3 = new BaseDataVariableState<double>(this);
                            }
                            else
                            {
                                filterPressureDiff3 = (BaseDataVariableState<double>)replacement;
                            }
                        }
                    }

                    instance = filterPressureDiff3;
                    break;
                }

                case Measurements.BrowseNames.flowRateRT4:
                {
                    if (createOrReplace)
                    {
                        if (flowRateRT4 == null)
                        {
                            if (replacement == null)
                            {
                                flowRateRT4 = new BaseDataVariableState<double>(this);
                            }
                            else
                            {
                                flowRateRT4 = (BaseDataVariableState<double>)replacement;
                            }
                        }
                    }

                    instance = flowRateRT4;
                    break;
                }

                case Measurements.BrowseNames.heatRT4:
                {
                    if (createOrReplace)
                    {
                        if (heatRT4 == null)
                        {
                            if (replacement == null)
                            {
                                heatRT4 = new BaseDataVariableState<double>(this);
                            }
                            else
                            {
                                heatRT4 = (BaseDataVariableState<double>)replacement;
                            }
                        }
                    }

                    instance = heatRT4;
                    break;
                }

                case Measurements.BrowseNames.flowRateRT5:
                {
                    if (createOrReplace)
                    {
                        if (flowRateRT5 == null)
                        {
                            if (replacement == null)
                            {
                                flowRateRT5 = new BaseDataVariableState<double>(this);
                            }
                            else
                            {
                                flowRateRT5 = (BaseDataVariableState<double>)replacement;
                            }
                        }
                    }

                    instance = flowRateRT5;
                    break;
                }

                case Measurements.BrowseNames.heatRT5:
                {
                    if (createOrReplace)
                    {
                        if (heatRT5 == null)
                        {
                            if (replacement == null)
                            {
                                heatRT5 = new BaseDataVariableState<double>(this);
                            }
                            else
                            {
                                heatRT5 = (BaseDataVariableState<double>)replacement;
                            }
                        }
                    }

                    instance = heatRT5;
                    break;
                }

                case Measurements.BrowseNames.flowRateRT6:
                {
                    if (createOrReplace)
                    {
                        if (flowRateRT6 == null)
                        {
                            if (replacement == null)
                            {
                                flowRateRT6 = new BaseDataVariableState<double>(this);
                            }
                            else
                            {
                                flowRateRT6 = (BaseDataVariableState<double>)replacement;
                            }
                        }
                    }

                    instance = flowRateRT6;
                    break;
                }

                case Measurements.BrowseNames.heatRT6:
                {
                    if (createOrReplace)
                    {
                        if (heatRT6 == null)
                        {
                            if (replacement == null)
                            {
                                heatRT6 = new BaseDataVariableState<double>(this);
                            }
                            else
                            {
                                heatRT6 = (BaseDataVariableState<double>)replacement;
                            }
                        }
                    }

                    instance = heatRT6;
                    break;
                }

                case Measurements.BrowseNames.valveOpenRate2:
                {
                    if (createOrReplace)
                    {
                        if (valveOpenRate2 == null)
                        {
                            if (replacement == null)
                            {
                                valveOpenRate2 = new BaseDataVariableState<double>(this);
                            }
                            else
                            {
                                valveOpenRate2 = (BaseDataVariableState<double>)replacement;
                            }
                        }
                    }

                    instance = valveOpenRate2;
                    break;
                }

                case Measurements.BrowseNames.tankLevel:
                {
                    if (createOrReplace)
                    {
                        if (tankLevel == null)
                        {
                            if (replacement == null)
                            {
                                tankLevel = new BaseDataVariableState<double>(this);
                            }
                            else
                            {
                                tankLevel = (BaseDataVariableState<double>)replacement;
                            }
                        }
                    }

                    instance = tankLevel;
                    break;
                }

                case Measurements.BrowseNames.flowRateRT7:
                {
                    if (createOrReplace)
                    {
                        if (flowRateRT7 == null)
                        {
                            if (replacement == null)
                            {
                                flowRateRT7 = new BaseDataVariableState<double>(this);
                            }
                            else
                            {
                                flowRateRT7 = (BaseDataVariableState<double>)replacement;
                            }
                        }
                    }

                    instance = flowRateRT7;
                    break;
                }

                case Measurements.BrowseNames.heatRT7:
                {
                    if (createOrReplace)
                    {
                        if (heatRT7 == null)
                        {
                            if (replacement == null)
                            {
                                heatRT7 = new BaseDataVariableState<double>(this);
                            }
                            else
                            {
                                heatRT7 = (BaseDataVariableState<double>)replacement;
                            }
                        }
                    }

                    instance = heatRT7;
                    break;
                }

                case Measurements.BrowseNames.waterLevel:
                {
                    if (createOrReplace)
                    {
                        if (waterLevel == null)
                        {
                            if (replacement == null)
                            {
                                waterLevel = new BaseDataVariableState<double>(this);
                            }
                            else
                            {
                                waterLevel = (BaseDataVariableState<double>)replacement;
                            }
                        }
                    }

                    instance = waterLevel;
                    break;
                }

                case Measurements.BrowseNames.heat_chart1:
                {
                    if (createOrReplace)
                    {
                        if (heat_chart1 == null)
                        {
                            if (replacement == null)
                            {
                                heat_chart1 = new BaseDataVariableState(this);
                            }
                            else
                            {
                                heat_chart1 = (BaseDataVariableState)replacement;
                            }
                        }
                    }

                    instance = heat_chart1;
                    break;
                }

                case Measurements.BrowseNames.heat_chart2:
                {
                    if (createOrReplace)
                    {
                        if (heat_chart2 == null)
                        {
                            if (replacement == null)
                            {
                                heat_chart2 = new BaseDataVariableState(this);
                            }
                            else
                            {
                                heat_chart2 = (BaseDataVariableState)replacement;
                            }
                        }
                    }

                    instance = heat_chart2;
                    break;
                }

                case Measurements.BrowseNames.heat_chart3_1:
                {
                    if (createOrReplace)
                    {
                        if (heat_chart3_1 == null)
                        {
                            if (replacement == null)
                            {
                                heat_chart3_1 = new BaseDataVariableState(this);
                            }
                            else
                            {
                                heat_chart3_1 = (BaseDataVariableState)replacement;
                            }
                        }
                    }

                    instance = heat_chart3_1;
                    break;
                }

                case Measurements.BrowseNames.heat_chart3_2:
                {
                    if (createOrReplace)
                    {
                        if (heat_chart3_2 == null)
                        {
                            if (replacement == null)
                            {
                                heat_chart3_2 = new BaseDataVariableState(this);
                            }
                            else
                            {
                                heat_chart3_2 = (BaseDataVariableState)replacement;
                            }
                        }
                    }

                    instance = heat_chart3_2;
                    break;
                }

                case Measurements.BrowseNames.heat_chart4_1:
                {
                    if (createOrReplace)
                    {
                        if (heat_chart4_1 == null)
                        {
                            if (replacement == null)
                            {
                                heat_chart4_1 = new BaseDataVariableState(this);
                            }
                            else
                            {
                                heat_chart4_1 = (BaseDataVariableState)replacement;
                            }
                        }
                    }

                    instance = heat_chart4_1;
                    break;
                }

                case Measurements.BrowseNames.heat_chart4_2:
                {
                    if (createOrReplace)
                    {
                        if (heat_chart4_2 == null)
                        {
                            if (replacement == null)
                            {
                                heat_chart4_2 = new BaseDataVariableState(this);
                            }
                            else
                            {
                                heat_chart4_2 = (BaseDataVariableState)replacement;
                            }
                        }
                    }

                    instance = heat_chart4_2;
                    break;
                }

                case Measurements.BrowseNames.heat_chart4_3:
                {
                    if (createOrReplace)
                    {
                        if (heat_chart4_3 == null)
                        {
                            if (replacement == null)
                            {
                                heat_chart4_3 = new BaseDataVariableState(this);
                            }
                            else
                            {
                                heat_chart4_3 = (BaseDataVariableState)replacement;
                            }
                        }
                    }

                    instance = heat_chart4_3;
                    break;
                }

                case Measurements.BrowseNames.heat_chart4_4:
                {
                    if (createOrReplace)
                    {
                        if (heat_chart4_4 == null)
                        {
                            if (replacement == null)
                            {
                                heat_chart4_4 = new BaseDataVariableState(this);
                            }
                            else
                            {
                                heat_chart4_4 = (BaseDataVariableState)replacement;
                            }
                        }
                    }

                    instance = heat_chart4_4;
                    break;
                }

                case Measurements.BrowseNames.yearPlan1:
                {
                    if (createOrReplace)
                    {
                        if (yearPlan1 == null)
                        {
                            if (replacement == null)
                            {
                                yearPlan1 = new BaseDataVariableState<double>(this);
                            }
                            else
                            {
                                yearPlan1 = (BaseDataVariableState<double>)replacement;
                            }
                        }
                    }

                    instance = yearPlan1;
                    break;
                }

                case Measurements.BrowseNames.yearPlan2:
                {
                    if (createOrReplace)
                    {
                        if (yearPlan2 == null)
                        {
                            if (replacement == null)
                            {
                                yearPlan2 = new BaseDataVariableState<double>(this);
                            }
                            else
                            {
                                yearPlan2 = (BaseDataVariableState<double>)replacement;
                            }
                        }
                    }

                    instance = yearPlan2;
                    break;
                }

                case Measurements.BrowseNames.yearPlan3:
                {
                    if (createOrReplace)
                    {
                        if (yearPlan3 == null)
                        {
                            if (replacement == null)
                            {
                                yearPlan3 = new BaseDataVariableState<double>(this);
                            }
                            else
                            {
                                yearPlan3 = (BaseDataVariableState<double>)replacement;
                            }
                        }
                    }

                    instance = yearPlan3;
                    break;
                }

                case Measurements.BrowseNames.monthPlan1:
                {
                    if (createOrReplace)
                    {
                        if (monthPlan1 == null)
                        {
                            if (replacement == null)
                            {
                                monthPlan1 = new BaseDataVariableState<double>(this);
                            }
                            else
                            {
                                monthPlan1 = (BaseDataVariableState<double>)replacement;
                            }
                        }
                    }

                    instance = monthPlan1;
                    break;
                }

                case Measurements.BrowseNames.monthPlan2:
                {
                    if (createOrReplace)
                    {
                        if (monthPlan2 == null)
                        {
                            if (replacement == null)
                            {
                                monthPlan2 = new BaseDataVariableState<double>(this);
                            }
                            else
                            {
                                monthPlan2 = (BaseDataVariableState<double>)replacement;
                            }
                        }
                    }

                    instance = monthPlan2;
                    break;
                }

                case Measurements.BrowseNames.monthPlan3:
                {
                    if (createOrReplace)
                    {
                        if (monthPlan3 == null)
                        {
                            if (replacement == null)
                            {
                                monthPlan3 = new BaseDataVariableState<double>(this);
                            }
                            else
                            {
                                monthPlan3 = (BaseDataVariableState<double>)replacement;
                            }
                        }
                    }

                    instance = monthPlan3;
                    break;
                }

                case Measurements.BrowseNames.monthPlan4:
                {
                    if (createOrReplace)
                    {
                        if (monthPlan4 == null)
                        {
                            if (replacement == null)
                            {
                                monthPlan4 = new BaseDataVariableState<double>(this);
                            }
                            else
                            {
                                monthPlan4 = (BaseDataVariableState<double>)replacement;
                            }
                        }
                    }

                    instance = monthPlan4;
                    break;
                }

                case Measurements.BrowseNames.dayPlan1:
                {
                    if (createOrReplace)
                    {
                        if (dayPlan1 == null)
                        {
                            if (replacement == null)
                            {
                                dayPlan1 = new BaseDataVariableState<double>(this);
                            }
                            else
                            {
                                dayPlan1 = (BaseDataVariableState<double>)replacement;
                            }
                        }
                    }

                    instance = dayPlan1;
                    break;
                }

                case Measurements.BrowseNames.dayPlan2:
                {
                    if (createOrReplace)
                    {
                        if (dayPlan2 == null)
                        {
                            if (replacement == null)
                            {
                                dayPlan2 = new BaseDataVariableState<double>(this);
                            }
                            else
                            {
                                dayPlan2 = (BaseDataVariableState<double>)replacement;
                            }
                        }
                    }

                    instance = dayPlan2;
                    break;
                }

                case Measurements.BrowseNames.dayPlan3:
                {
                    if (createOrReplace)
                    {
                        if (dayPlan3 == null)
                        {
                            if (replacement == null)
                            {
                                dayPlan3 = new BaseDataVariableState<double>(this);
                            }
                            else
                            {
                                dayPlan3 = (BaseDataVariableState<double>)replacement;
                            }
                        }
                    }

                    instance = dayPlan3;
                    break;
                }

                case Measurements.BrowseNames.dayPlan4:
                {
                    if (createOrReplace)
                    {
                        if (dayPlan4 == null)
                        {
                            if (replacement == null)
                            {
                                dayPlan4 = new BaseDataVariableState<double>(this);
                            }
                            else
                            {
                                dayPlan4 = (BaseDataVariableState<double>)replacement;
                            }
                        }
                    }

                    instance = dayPlan4;
                    break;
                }

                case Measurements.BrowseNames.storeData1:
                {
                    if (createOrReplace)
                    {
                        if (storeData1 == null)
                        {
                            if (replacement == null)
                            {
                                storeData1 = new BaseDataVariableState<double>(this);
                            }
                            else
                            {
                                storeData1 = (BaseDataVariableState<double>)replacement;
                            }
                        }
                    }

                    instance = storeData1;
                    break;
                }

                case Measurements.BrowseNames.storeData2:
                {
                    if (createOrReplace)
                    {
                        if (storeData2 == null)
                        {
                            if (replacement == null)
                            {
                                storeData2 = new BaseDataVariableState<double>(this);
                            }
                            else
                            {
                                storeData2 = (BaseDataVariableState<double>)replacement;
                            }
                        }
                    }

                    instance = storeData2;
                    break;
                }

                case Measurements.BrowseNames.storeData3:
                {
                    if (createOrReplace)
                    {
                        if (storeData3 == null)
                        {
                            if (replacement == null)
                            {
                                storeData3 = new BaseDataVariableState<double>(this);
                            }
                            else
                            {
                                storeData3 = (BaseDataVariableState<double>)replacement;
                            }
                        }
                    }

                    instance = storeData3;
                    break;
                }

                case Measurements.BrowseNames.meter_chart1_1:
                {
                    if (createOrReplace)
                    {
                        if (meter_chart1_1 == null)
                        {
                            if (replacement == null)
                            {
                                meter_chart1_1 = new BaseDataVariableState(this);
                            }
                            else
                            {
                                meter_chart1_1 = (BaseDataVariableState)replacement;
                            }
                        }
                    }

                    instance = meter_chart1_1;
                    break;
                }

                case Measurements.BrowseNames.meter_chart1_2:
                {
                    if (createOrReplace)
                    {
                        if (meter_chart1_2 == null)
                        {
                            if (replacement == null)
                            {
                                meter_chart1_2 = new BaseDataVariableState(this);
                            }
                            else
                            {
                                meter_chart1_2 = (BaseDataVariableState)replacement;
                            }
                        }
                    }

                    instance = meter_chart1_2;
                    break;
                }

                case Measurements.BrowseNames.meter_chart2_1:
                {
                    if (createOrReplace)
                    {
                        if (meter_chart2_1 == null)
                        {
                            if (replacement == null)
                            {
                                meter_chart2_1 = new BaseDataVariableState(this);
                            }
                            else
                            {
                                meter_chart2_1 = (BaseDataVariableState)replacement;
                            }
                        }
                    }

                    instance = meter_chart2_1;
                    break;
                }

                case Measurements.BrowseNames.meter_chart2_2:
                {
                    if (createOrReplace)
                    {
                        if (meter_chart2_2 == null)
                        {
                            if (replacement == null)
                            {
                                meter_chart2_2 = new BaseDataVariableState(this);
                            }
                            else
                            {
                                meter_chart2_2 = (BaseDataVariableState)replacement;
                            }
                        }
                    }

                    instance = meter_chart2_2;
                    break;
                }

                case Measurements.BrowseNames.meter_chart3_1:
                {
                    if (createOrReplace)
                    {
                        if (meter_chart3_1 == null)
                        {
                            if (replacement == null)
                            {
                                meter_chart3_1 = new BaseDataVariableState(this);
                            }
                            else
                            {
                                meter_chart3_1 = (BaseDataVariableState)replacement;
                            }
                        }
                    }

                    instance = meter_chart3_1;
                    break;
                }

                case Measurements.BrowseNames.meter_chart3_2:
                {
                    if (createOrReplace)
                    {
                        if (meter_chart3_2 == null)
                        {
                            if (replacement == null)
                            {
                                meter_chart3_2 = new BaseDataVariableState(this);
                            }
                            else
                            {
                                meter_chart3_2 = (BaseDataVariableState)replacement;
                            }
                        }
                    }

                    instance = meter_chart3_2;
                    break;
                }

                case Measurements.BrowseNames.meter_table:
                {
                    if (createOrReplace)
                    {
                        if (meter_table == null)
                        {
                            if (replacement == null)
                            {
                                meter_table = new BaseDataVariableState(this);
                            }
                            else
                            {
                                meter_table = (BaseDataVariableState)replacement;
                            }
                        }
                    }

                    instance = meter_table;
                    break;
                }

                case Measurements.BrowseNames.temperatures:
                {
                    if (createOrReplace)
                    {
                        if (temperatures == null)
                        {
                            if (replacement == null)
                            {
                                temperatures = new BaseDataVariableState(this);
                            }
                            else
                            {
                                temperatures = (BaseDataVariableState)replacement;
                            }
                        }
                    }

                    instance = temperatures;
                    break;
                }

                case Measurements.BrowseNames.pressures:
                {
                    if (createOrReplace)
                    {
                        if (pressures == null)
                        {
                            if (replacement == null)
                            {
                                pressures = new BaseDataVariableState(this);
                            }
                            else
                            {
                                pressures = (BaseDataVariableState)replacement;
                            }
                        }
                    }

                    instance = pressures;
                    break;
                }

                case Measurements.BrowseNames.furnace_chart1_1:
                {
                    if (createOrReplace)
                    {
                        if (furnace_chart1_1 == null)
                        {
                            if (replacement == null)
                            {
                                furnace_chart1_1 = new BaseDataVariableState(this);
                            }
                            else
                            {
                                furnace_chart1_1 = (BaseDataVariableState)replacement;
                            }
                        }
                    }

                    instance = furnace_chart1_1;
                    break;
                }

                case Measurements.BrowseNames.furnace_chart1_2:
                {
                    if (createOrReplace)
                    {
                        if (furnace_chart1_2 == null)
                        {
                            if (replacement == null)
                            {
                                furnace_chart1_2 = new BaseDataVariableState(this);
                            }
                            else
                            {
                                furnace_chart1_2 = (BaseDataVariableState)replacement;
                            }
                        }
                    }

                    instance = furnace_chart1_2;
                    break;
                }

                case Measurements.BrowseNames.furnace_chart2_1:
                {
                    if (createOrReplace)
                    {
                        if (furnace_chart2_1 == null)
                        {
                            if (replacement == null)
                            {
                                furnace_chart2_1 = new BaseDataVariableState(this);
                            }
                            else
                            {
                                furnace_chart2_1 = (BaseDataVariableState)replacement;
                            }
                        }
                    }

                    instance = furnace_chart2_1;
                    break;
                }

                case Measurements.BrowseNames.furnace_chart2_2:
                {
                    if (createOrReplace)
                    {
                        if (furnace_chart2_2 == null)
                        {
                            if (replacement == null)
                            {
                                furnace_chart2_2 = new BaseDataVariableState(this);
                            }
                            else
                            {
                                furnace_chart2_2 = (BaseDataVariableState)replacement;
                            }
                        }
                    }

                    instance = furnace_chart2_2;
                    break;
                }

                case Measurements.BrowseNames.blastfurnace_energy:
                {
                    if (createOrReplace)
                    {
                        if (blastfurnace_energy == null)
                        {
                            if (replacement == null)
                            {
                                blastfurnace_energy = new BaseDataVariableState(this);
                            }
                            else
                            {
                                blastfurnace_energy = (BaseDataVariableState)replacement;
                            }
                        }
                    }

                    instance = blastfurnace_energy;
                    break;
                }

                case Measurements.BrowseNames.blastfurnace_yield:
                {
                    if (createOrReplace)
                    {
                        if (blastfurnace_yield == null)
                        {
                            if (replacement == null)
                            {
                                blastfurnace_yield = new BaseDataVariableState(this);
                            }
                            else
                            {
                                blastfurnace_yield = (BaseDataVariableState)replacement;
                            }
                        }
                    }

                    instance = blastfurnace_yield;
                    break;
                }

                case Measurements.BrowseNames.blastfurnace_condition:
                {
                    if (createOrReplace)
                    {
                        if (blastfurnace_condition == null)
                        {
                            if (replacement == null)
                            {
                                blastfurnace_condition = new BaseDataVariableState(this);
                            }
                            else
                            {
                                blastfurnace_condition = (BaseDataVariableState)replacement;
                            }
                        }
                    }

                    instance = blastfurnace_condition;
                    break;
                }

                case Measurements.BrowseNames.blastfurnace_chart1_1:
                {
                    if (createOrReplace)
                    {
                        if (blastfurnace_chart1_1 == null)
                        {
                            if (replacement == null)
                            {
                                blastfurnace_chart1_1 = new BaseDataVariableState(this);
                            }
                            else
                            {
                                blastfurnace_chart1_1 = (BaseDataVariableState)replacement;
                            }
                        }
                    }

                    instance = blastfurnace_chart1_1;
                    break;
                }

                case Measurements.BrowseNames.blastfurnace_chart1_2:
                {
                    if (createOrReplace)
                    {
                        if (blastfurnace_chart1_2 == null)
                        {
                            if (replacement == null)
                            {
                                blastfurnace_chart1_2 = new BaseDataVariableState(this);
                            }
                            else
                            {
                                blastfurnace_chart1_2 = (BaseDataVariableState)replacement;
                            }
                        }
                    }

                    instance = blastfurnace_chart1_2;
                    break;
                }

                case Measurements.BrowseNames.blastfurnace_chart2_1:
                {
                    if (createOrReplace)
                    {
                        if (blastfurnace_chart2_1 == null)
                        {
                            if (replacement == null)
                            {
                                blastfurnace_chart2_1 = new BaseDataVariableState(this);
                            }
                            else
                            {
                                blastfurnace_chart2_1 = (BaseDataVariableState)replacement;
                            }
                        }
                    }

                    instance = blastfurnace_chart2_1;
                    break;
                }

                case Measurements.BrowseNames.blastfurnace_chart2_2:
                {
                    if (createOrReplace)
                    {
                        if (blastfurnace_chart2_2 == null)
                        {
                            if (replacement == null)
                            {
                                blastfurnace_chart2_2 = new BaseDataVariableState(this);
                            }
                            else
                            {
                                blastfurnace_chart2_2 = (BaseDataVariableState)replacement;
                            }
                        }
                    }

                    instance = blastfurnace_chart2_2;
                    break;
                }

                case Measurements.BrowseNames.blastfurnace_chart2_3:
                {
                    if (createOrReplace)
                    {
                        if (blastfurnace_chart2_3 == null)
                        {
                            if (replacement == null)
                            {
                                blastfurnace_chart2_3 = new BaseDataVariableState(this);
                            }
                            else
                            {
                                blastfurnace_chart2_3 = (BaseDataVariableState)replacement;
                            }
                        }
                    }

                    instance = blastfurnace_chart2_3;
                    break;
                }

                case Measurements.BrowseNames.blastfurnace_chart2_4:
                {
                    if (createOrReplace)
                    {
                        if (blastfurnace_chart2_4 == null)
                        {
                            if (replacement == null)
                            {
                                blastfurnace_chart2_4 = new BaseDataVariableState(this);
                            }
                            else
                            {
                                blastfurnace_chart2_4 = (BaseDataVariableState)replacement;
                            }
                        }
                    }

                    instance = blastfurnace_chart2_4;
                    break;
                }

                case Measurements.BrowseNames.blastfurnace_chart2_5:
                {
                    if (createOrReplace)
                    {
                        if (blastfurnace_chart2_5 == null)
                        {
                            if (replacement == null)
                            {
                                blastfurnace_chart2_5 = new BaseDataVariableState(this);
                            }
                            else
                            {
                                blastfurnace_chart2_5 = (BaseDataVariableState)replacement;
                            }
                        }
                    }

                    instance = blastfurnace_chart2_5;
                    break;
                }

                case Measurements.BrowseNames.blastfurnace_chart2_6:
                {
                    if (createOrReplace)
                    {
                        if (blastfurnace_chart2_6 == null)
                        {
                            if (replacement == null)
                            {
                                blastfurnace_chart2_6 = new BaseDataVariableState(this);
                            }
                            else
                            {
                                blastfurnace_chart2_6 = (BaseDataVariableState)replacement;
                            }
                        }
                    }

                    instance = blastfurnace_chart2_6;
                    break;
                }

                case Measurements.BrowseNames.blastfurnace_chart2_7:
                {
                    if (createOrReplace)
                    {
                        if (blastfurnace_chart2_7 == null)
                        {
                            if (replacement == null)
                            {
                                blastfurnace_chart2_7 = new BaseDataVariableState(this);
                            }
                            else
                            {
                                blastfurnace_chart2_7 = (BaseDataVariableState)replacement;
                            }
                        }
                    }

                    instance = blastfurnace_chart2_7;
                    break;
                }

                case Measurements.BrowseNames.blastfurnace_chart2_8:
                {
                    if (createOrReplace)
                    {
                        if (blastfurnace_chart2_8 == null)
                        {
                            if (replacement == null)
                            {
                                blastfurnace_chart2_8 = new BaseDataVariableState(this);
                            }
                            else
                            {
                                blastfurnace_chart2_8 = (BaseDataVariableState)replacement;
                            }
                        }
                    }

                    instance = blastfurnace_chart2_8;
                    break;
                }

                case Measurements.BrowseNames.blastfurnace_chart3_1:
                {
                    if (createOrReplace)
                    {
                        if (blastfurnace_chart3_1 == null)
                        {
                            if (replacement == null)
                            {
                                blastfurnace_chart3_1 = new BaseDataVariableState(this);
                            }
                            else
                            {
                                blastfurnace_chart3_1 = (BaseDataVariableState)replacement;
                            }
                        }
                    }

                    instance = blastfurnace_chart3_1;
                    break;
                }

                case Measurements.BrowseNames.blastfurnace_chart3_2:
                {
                    if (createOrReplace)
                    {
                        if (blastfurnace_chart3_2 == null)
                        {
                            if (replacement == null)
                            {
                                blastfurnace_chart3_2 = new BaseDataVariableState(this);
                            }
                            else
                            {
                                blastfurnace_chart3_2 = (BaseDataVariableState)replacement;
                            }
                        }
                    }

                    instance = blastfurnace_chart3_2;
                    break;
                }

                case Measurements.BrowseNames.blastfurnace_chart3_3:
                {
                    if (createOrReplace)
                    {
                        if (blastfurnace_chart3_3 == null)
                        {
                            if (replacement == null)
                            {
                                blastfurnace_chart3_3 = new BaseDataVariableState(this);
                            }
                            else
                            {
                                blastfurnace_chart3_3 = (BaseDataVariableState)replacement;
                            }
                        }
                    }

                    instance = blastfurnace_chart3_3;
                    break;
                }

                case Measurements.BrowseNames.blastfurnace_chart4_1:
                {
                    if (createOrReplace)
                    {
                        if (blastfurnace_chart4_1 == null)
                        {
                            if (replacement == null)
                            {
                                blastfurnace_chart4_1 = new BaseDataVariableState(this);
                            }
                            else
                            {
                                blastfurnace_chart4_1 = (BaseDataVariableState)replacement;
                            }
                        }
                    }

                    instance = blastfurnace_chart4_1;
                    break;
                }

                case Measurements.BrowseNames.blastfurnace_chart4_2:
                {
                    if (createOrReplace)
                    {
                        if (blastfurnace_chart4_2 == null)
                        {
                            if (replacement == null)
                            {
                                blastfurnace_chart4_2 = new BaseDataVariableState(this);
                            }
                            else
                            {
                                blastfurnace_chart4_2 = (BaseDataVariableState)replacement;
                            }
                        }
                    }

                    instance = blastfurnace_chart4_2;
                    break;
                }

                case Measurements.BrowseNames.blastfurnace_chart4_3:
                {
                    if (createOrReplace)
                    {
                        if (blastfurnace_chart4_3 == null)
                        {
                            if (replacement == null)
                            {
                                blastfurnace_chart4_3 = new BaseDataVariableState(this);
                            }
                            else
                            {
                                blastfurnace_chart4_3 = (BaseDataVariableState)replacement;
                            }
                        }
                    }

                    instance = blastfurnace_chart4_3;
                    break;
                }

                case Measurements.BrowseNames.blastfurnace_chart4_4:
                {
                    if (createOrReplace)
                    {
                        if (blastfurnace_chart4_4 == null)
                        {
                            if (replacement == null)
                            {
                                blastfurnace_chart4_4 = new BaseDataVariableState(this);
                            }
                            else
                            {
                                blastfurnace_chart4_4 = (BaseDataVariableState)replacement;
                            }
                        }
                    }

                    instance = blastfurnace_chart4_4;
                    break;
                }
            }

            if (instance != null)
            {
                return instance;
            }

            return base.FindChild(context, browseName, createOrReplace, replacement);
        }
        #endregion

        #region Private Fields
        private AnalogUnitState<double> m_temperature;
        private AnalogUnitState<double> m_pressure;
        private MeasurementResetMethodState m_resetMethod;
        private BaseDataVariableState<OrientationDataType> m_orientation;
        private BaseDataVariableState<double> m_speed;
        private BaseDataVariableState m_arrayTest;
        private BaseDataVariableState<bool> m_booleanTest;
        private BaseDataVariableState<int> m_switch0;
        private BaseDataVariableState<bool> m_switch1;
        private BaseDataVariableState<bool> m_switch2;
        private BaseDataVariableState<bool> m_switch3;
        private BaseDataVariableState<bool> m_switch4;
        private BaseDataVariableState<double> m_flowRateRT;
        private BaseDataVariableState<double> m_heatRT;
        private BaseDataVariableState<double> m_valveOpenRate;
        private BaseDataVariableState<double> m_returnWaterPressure;
        private BaseDataVariableState<double> m_returnWaterTemp;
        private BaseDataVariableState<double> m_supplyWaterPressure;
        private BaseDataVariableState<double> m_supplyWaterTemp;
        private BaseDataVariableState<double> m_pumpFreq1;
        private BaseDataVariableState<double> m_returnWaterPressure2;
        private BaseDataVariableState<double> m_returnWaterTemp2;
        private BaseDataVariableState<double> m_flowRateRT2;
        private BaseDataVariableState<double> m_heatRT2;
        private BaseDataVariableState<double> m_filterPressureDiff;
        private BaseDataVariableState<double> m_supplyWaterPressure2;
        private BaseDataVariableState<double> m_supplyWaterTemp2;
        private BaseDataVariableState<double> m_supplyWaterPressure3;
        private BaseDataVariableState<double> m_supplyWaterTemp3;
        private BaseDataVariableState<double> m_pumpFreq2;
        private BaseDataVariableState<double> m_pumpFreq3;
        private BaseDataVariableState<double> m_pumpFreq4;
        private BaseDataVariableState<double> m_returnWaterPressure3;
        private BaseDataVariableState<double> m_returnWaterTemp3;
        private BaseDataVariableState<double> m_filterPressureDiff2;
        private BaseDataVariableState<double> m_flowRateRT3;
        private BaseDataVariableState<double> m_heatRT3;
        private BaseDataVariableState<double> m_filterPressureDiff3;
        private BaseDataVariableState<double> m_flowRateRT4;
        private BaseDataVariableState<double> m_heatRT4;
        private BaseDataVariableState<double> m_flowRateRT5;
        private BaseDataVariableState<double> m_heatRT5;
        private BaseDataVariableState<double> m_flowRateRT6;
        private BaseDataVariableState<double> m_heatRT6;
        private BaseDataVariableState<double> m_valveOpenRate2;
        private BaseDataVariableState<double> m_tankLevel;
        private BaseDataVariableState<double> m_flowRateRT7;
        private BaseDataVariableState<double> m_heatRT7;
        private BaseDataVariableState<double> m_waterLevel;
        private BaseDataVariableState m_heat_chart1;
        private BaseDataVariableState m_heat_chart2;
        private BaseDataVariableState m_heat_chart3_1;
        private BaseDataVariableState m_heat_chart3_2;
        private BaseDataVariableState m_heat_chart4_1;
        private BaseDataVariableState m_heat_chart4_2;
        private BaseDataVariableState m_heat_chart4_3;
        private BaseDataVariableState m_heat_chart4_4;
        private BaseDataVariableState<double> m_yearPlan1;
        private BaseDataVariableState<double> m_yearPlan2;
        private BaseDataVariableState<double> m_yearPlan3;
        private BaseDataVariableState<double> m_monthPlan1;
        private BaseDataVariableState<double> m_monthPlan2;
        private BaseDataVariableState<double> m_monthPlan3;
        private BaseDataVariableState<double> m_monthPlan4;
        private BaseDataVariableState<double> m_dayPlan1;
        private BaseDataVariableState<double> m_dayPlan2;
        private BaseDataVariableState<double> m_dayPlan3;
        private BaseDataVariableState<double> m_dayPlan4;
        private BaseDataVariableState<double> m_storeData1;
        private BaseDataVariableState<double> m_storeData2;
        private BaseDataVariableState<double> m_storeData3;
        private BaseDataVariableState m_meter_chart1_1;
        private BaseDataVariableState m_meter_chart1_2;
        private BaseDataVariableState m_meter_chart2_1;
        private BaseDataVariableState m_meter_chart2_2;
        private BaseDataVariableState m_meter_chart3_1;
        private BaseDataVariableState m_meter_chart3_2;
        private BaseDataVariableState m_meter_table;
        private BaseDataVariableState m_temperatures;
        private BaseDataVariableState m_pressures;
        private BaseDataVariableState m_furnace_chart1_1;
        private BaseDataVariableState m_furnace_chart1_2;
        private BaseDataVariableState m_furnace_chart2_1;
        private BaseDataVariableState m_furnace_chart2_2;
        private BaseDataVariableState m_blastfurnace_energy;
        private BaseDataVariableState m_blastfurnace_yield;
        private BaseDataVariableState m_blastfurnace_condition;
        private BaseDataVariableState m_blastfurnace_chart1_1;
        private BaseDataVariableState m_blastfurnace_chart1_2;
        private BaseDataVariableState m_blastfurnace_chart2_1;
        private BaseDataVariableState m_blastfurnace_chart2_2;
        private BaseDataVariableState m_blastfurnace_chart2_3;
        private BaseDataVariableState m_blastfurnace_chart2_4;
        private BaseDataVariableState m_blastfurnace_chart2_5;
        private BaseDataVariableState m_blastfurnace_chart2_6;
        private BaseDataVariableState m_blastfurnace_chart2_7;
        private BaseDataVariableState m_blastfurnace_chart2_8;
        private BaseDataVariableState m_blastfurnace_chart3_1;
        private BaseDataVariableState m_blastfurnace_chart3_2;
        private BaseDataVariableState m_blastfurnace_chart3_3;
        private BaseDataVariableState m_blastfurnace_chart4_1;
        private BaseDataVariableState m_blastfurnace_chart4_2;
        private BaseDataVariableState m_blastfurnace_chart4_3;
        private BaseDataVariableState m_blastfurnace_chart4_4;
        #endregion
    }
    #endif
    #endregion

    #region MeasurementResetMethodState Class
    #if (!OPCUA_EXCLUDE_MeasurementResetMethodState)
    /// <remarks />
    /// <exclude />
    [System.CodeDom.Compiler.GeneratedCodeAttribute("Opc.Ua.ModelCompiler", "1.0.0.0")]
    public partial class MeasurementResetMethodState : MethodState
    {
        #region Constructors
        /// <remarks />
        public MeasurementResetMethodState(NodeState parent) : base(parent)
        {
        }

        /// <remarks />
        public new static NodeState Construct(NodeState parent)
        {
            return new MeasurementResetMethodState(parent);
        }

        #if (!OPCUA_EXCLUDE_InitializationStrings)
        /// <remarks />
        protected override void Initialize(ISystemContext context)
        {
            base.Initialize(context);
            Initialize(context, InitializationString);
            InitializeOptionalChildren(context);
        }

        /// <remarks />
        protected override void InitializeOptionalChildren(ISystemContext context)
        {
            base.InitializeOptionalChildren(context);
        }

        #region Initialization String
        private const string InitializationString =
           "AQAAADUAAAB1cm46b3BjZm91bmRhdGlvbi5vcmc6MjAyNC0xMDpzdGFydGVya2l0Om1lYXN1cmVtZW50" +
           "c/////8EYYIKBAAAAAEAGgAAAE1lYXN1cmVtZW50UmVzZXRNZXRob2RUeXBlAQEcAAAvAQEcABwAAAAB" +
           "Af////8CAAAAF2CpCgIAAAAAAA4AAABJbnB1dEFyZ3VtZW50cwEBHQAALgBEHQAAAJYCAAAAAQAqAQEd" +
           "AAAADgAAAE5ld1RlbXBlcmF0dXJlAAv/////AAAAAAABACoBARoAAAALAAAATmV3UHJlc3N1cmUAC///" +
           "//8AAAAAAAEAKAEBAAAAAQAAAAIAAAABAf////8AAAAAF2CpCgIAAAAAAA8AAABPdXRwdXRBcmd1bWVu" +
           "dHMBAR4AAC4ARB4AAACWAgAAAAEAKgEBHQAAAA4AAABPbGRUZW1wZXJhdHVyZQAL/////wAAAAAAAQAq" +
           "AQEaAAAACwAAAE9sZFByZXNzdXJlAAv/////AAAAAAABACgBAQAAAAEAAAACAAAAAQH/////AAAAAA==";
        #endregion
        #endif
        #endregion

        #region Event Callbacks
        /// <remarks />
        public MeasurementResetMethodStateMethodCallHandler OnCall;
        #endregion

        #region Public Properties
        #endregion

        #region Overridden Methods
        /// <remarks />
        protected override ServiceResult Call(
            ISystemContext _context,
            NodeId _objectId,
            IList<object> _inputArguments,
            IList<object> _outputArguments)
        {
            if (OnCall == null)
            {
                return base.Call(_context, _objectId, _inputArguments, _outputArguments);
            }

            ServiceResult _result = null;

            double newTemperature = (double)_inputArguments[0];
            double newPressure = (double)_inputArguments[1];

            double oldTemperature = (double)_outputArguments[0];
            double oldPressure = (double)_outputArguments[1];

            if (OnCall != null)
            {
                _result = OnCall(
                    _context,
                    this,
                    _objectId,
                    newTemperature,
                    newPressure,
                    ref oldTemperature,
                    ref oldPressure);
            }

            _outputArguments[0] = oldTemperature;
            _outputArguments[1] = oldPressure;

            return _result;
        }
        #endregion

        #region Private Fields
        #endregion
    }

    /// <remarks />
    /// <exclude />
    public delegate ServiceResult MeasurementResetMethodStateMethodCallHandler(
        ISystemContext _context,
        MethodState _method,
        NodeId _objectId,
        double newTemperature,
        double newPressure,
        ref double oldTemperature,
        ref double oldPressure);
    #endif
    #endregion
}